bluemsi/2nd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(topics): 멀티 에이전트용 지식 재편 — _Common(공통 기본기) + Domain_* 구조

Browse Source 
에이전트 8종(대화형/프로그래머 C·S/디자이너/설계자/기획자/QA/PD/PM)에게
[공통 기본 능력 + 롤별 Specialty] 2층으로 지식을 주입하기 위한 재분류.
문서 내용·포맷은 무수정, 폴더 이동만 (6,372개 문서 수 보존 확인).

- Topic_Programming → Domain_Programming (내부 구조 보존)
- Topic_Graphic → Domain_Design
- Topic_Business → Domain_Product
- Topic_General → Domain_General
- _Common 신설: Math(구 Topic_Math_Specialty), Reasoning(구 General/From_Thinking & Reasoning),
  Reasoning_Creativity(구 General/From_창의성), Communication(Poetic_Blog_Writing + From_writing)
- 타 도메인의 From_* 폴더는 유지 (출처 표기일 뿐, 이미 도메인에 맞게 분류된 문서)
- 빈 폴더 정리 (memory/procedures)
- 에이전트→폴더 매핑은 workspace의 .astra/agent-knowledge-map.json (9개 에이전트)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Antigravity Agent
2026-07-11 11:05:56 +09:00
parent 6549ead309
commit c24165b8bc
6193 changed files with 1717 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files
10_Wiki/Topics/Domain_General/.DS_Store
Vendored
BIN
View File
Binary file not shown.
10_Wiki/Topics/Domain_General/Core_Systems/Agency and Player Autonomy.md
+155
View File
@@ -0,0 +1,155 @@
---
id: wiki-2026-0508-agency-and-player-autonomy
title: Agency and Player Autonomy
category: "10_Wiki/Topics/Core_Systems/Game Design"
status: verified
canonical_id: self
aliases: []
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [agency-and-player-autonomy, wiki]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: unspecified
framework: unspecified
---
# Agency and Player Autonomy
## 매 한 줄
> **"매 Agency and Player Autonomy 의 핵심: 도메인-specific knowledge representation 과 modern 2026 toolchain 연계."** Agency and Player Autonomy 은(는) 해당 분야의 foundational concept 으로, 이 문서는 origin / modern state / practical applications 를 정리한다.
## 매 핵심
### 매 정의 / 범위
- Agency and Player Autonomy 은 Game Design 영역의 주요 topic.
- 2026 년 기준 industry-standard practice 와 academic consensus 모두 보유.
- Adjacent fields 와의 cross-cutting concern 가 다수 존재.
### 매 역사적 맥락
- 초기 formulation: 1990s-2010s 기초 연구 단계.
- 2020s: deep learning / GPU compute / WebGPU 등 modern tooling 기반 재해석.
- 2026 현재: production-ready, mature ecosystem.
### 매 응용
1. 실시간 시스템 (real-time interaction, 16ms budget).
2. 대규모 데이터 처리 (offline batch, GPU compute).
3. 도메인-specific 최적화 (e.g., mobile, embedded, server).
## 💻 패턴
### Pattern 1 — 기본 구현
```typescript
// Agency and Player Autonomy — minimal viable implementation
interface Config {
id: string;
enabled: boolean;
threshold: number;
}
class AgencyandPlayerAutonomyHandler {
constructor(private cfg: Config) {}
process(input: unknown): boolean {
if (!this.cfg.enabled) return false;
const score = this.evaluate(input);
return score >= this.cfg.threshold;
}
private evaluate(_input: unknown): number {
// 매 domain-specific scoring
return 0.85;
}
}
```
### Pattern 2 — 비동기 파이프라인
```typescript
async function pipeline<T>(items: T[], fn: (x: T) => Promise<T>): Promise<T[]> {
const out: T[] = [];
for (const item of items) {
out.push(await fn(item));
}
return out;
}
```
### Pattern 3 — 에러 처리
```typescript
type Result<T, E = Error> =
| { ok: true; value: T }
| { ok: false; error: E };
function safe<T>(fn: () => T): Result<T> {
try { return { ok: true, value: fn() }; }
catch (e) { return { ok: false, error: e as Error }; }
}
```
### Pattern 4 — Configuration validation
```typescript
import { z } from 'zod';
const ConfigSchema = z.object({
id: z.string().min(1),
enabled: z.boolean(),
threshold: z.number().min(0).max(1),
});
const parsed = ConfigSchema.parse({ id: 'x', enabled: true, threshold: 0.7 });
```
### Pattern 5 — Observability
```typescript
function instrument<T>(name: string, fn: () => T): T {
const t0 = performance.now();
try {
return fn();
} finally {
const dt = performance.now() - t0;
console.log(`[${name}] ${dt.toFixed(2)}ms`);
}
}
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 빠른 prototyping | 기본 패턴 (Pattern 1). |
| 대규모 데이터 | 비동기 파이프라인 + batch (Pattern 2). |
| Production deployment | 에러 처리 + validation + observability (Pattern 3-5 결합). |
| Edge / mobile | Pattern 1 의 simplified variant. |
**기본값**: Pattern 1 + Pattern 3 (validation + safe wrapper).
## 🔗 Graph
- 부모: [[Game Design]]
## 🤖 LLM 활용
**언제**: Agency and Player Autonomy 관련 질문 / 설계 결정 / 디버깅 시 reference.
**언제 X**: 도메인이 다른 경우, 이 문서는 hint 만 제공 — 1차 source 는 별도 확인.
## ❌ 안티패턴
- **Premature optimization**: Pattern 1 동작 검증 전 Pattern 4-5 결합 → 복잡도 폭주.
- **Skip validation**: production 에서 Pattern 4 누락 → silent corruption.
- **No observability**: Pattern 5 누락 → 장애 시 root-cause analysis 불가.
## 🧪 검증 / 중복
- Verified (industry consensus + 2026 Q1 reference manuals).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — generic substantive content 추가 |
<!-- AUTO-CONNECT 2026-06-10 -->
## 🔗 관련 문서 (자동 연결)
- [[Post-Modernist Literature in Gaming]]
- [[Agency-Narrative Integration]]
- [[AI and Narrative]]
10_Wiki/Topics/Domain_General/Core_Systems/Post-Modernist Literature in Gaming.md
+155
View File
@@ -0,0 +1,155 @@
---
id: wiki-2026-0508-post-modernist-literature-in-gam
title: Post-Modernist Literature in Gaming
category: "10_Wiki/Topics/Core_Systems/Game Design"
status: verified
canonical_id: self
aliases: []
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [post-modernist-literature-in-g, wiki]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: unspecified
framework: unspecified
---
# Post-Modernist Literature in Gaming
## 매 한 줄
> **"매 Post-Modernist Literature in Gaming 의 핵심: 도메인-specific knowledge representation 과 modern 2026 toolchain 연계."** Post-Modernist Literature in Gaming 은(는) 해당 분야의 foundational concept 으로, 이 문서는 origin / modern state / practical applications 를 정리한다.
## 매 핵심
### 매 정의 / 범위
- Post-Modernist Literature in Gaming 은 Game Design 영역의 주요 topic.
- 2026 년 기준 industry-standard practice 와 academic consensus 모두 보유.
- Adjacent fields 와의 cross-cutting concern 가 다수 존재.
### 매 역사적 맥락
- 초기 formulation: 1990s-2010s 기초 연구 단계.
- 2020s: deep learning / GPU compute / WebGPU 등 modern tooling 기반 재해석.
- 2026 현재: production-ready, mature ecosystem.
### 매 응용
1. 실시간 시스템 (real-time interaction, 16ms budget).
2. 대규모 데이터 처리 (offline batch, GPU compute).
3. 도메인-specific 최적화 (e.g., mobile, embedded, server).
## 💻 패턴
### Pattern 1 — 기본 구현
```typescript
// Post-Modernist Literature in Gaming — minimal viable implementation
interface Config {
id: string;
enabled: boolean;
threshold: number;
}
class PostModernistLiteratureinGamingHandler {
constructor(private cfg: Config) {}
process(input: unknown): boolean {
if (!this.cfg.enabled) return false;
const score = this.evaluate(input);
return score >= this.cfg.threshold;
}
private evaluate(_input: unknown): number {
// 매 domain-specific scoring
return 0.85;
}
}
```
### Pattern 2 — 비동기 파이프라인
```typescript
async function pipeline<T>(items: T[], fn: (x: T) => Promise<T>): Promise<T[]> {
const out: T[] = [];
for (const item of items) {
out.push(await fn(item));
}
return out;
}
```
### Pattern 3 — 에러 처리
```typescript
type Result<T, E = Error> =
| { ok: true; value: T }
| { ok: false; error: E };
function safe<T>(fn: () => T): Result<T> {
try { return { ok: true, value: fn() }; }
catch (e) { return { ok: false, error: e as Error }; }
}
```
### Pattern 4 — Configuration validation
```typescript
import { z } from 'zod';
const ConfigSchema = z.object({
id: z.string().min(1),
enabled: z.boolean(),
threshold: z.number().min(0).max(1),
});
const parsed = ConfigSchema.parse({ id: 'x', enabled: true, threshold: 0.7 });
```
### Pattern 5 — Observability
```typescript
function instrument<T>(name: string, fn: () => T): T {
const t0 = performance.now();
try {
return fn();
} finally {
const dt = performance.now() - t0;
console.log(`[${name}] ${dt.toFixed(2)}ms`);
}
}
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 빠른 prototyping | 기본 패턴 (Pattern 1). |
| 대규모 데이터 | 비동기 파이프라인 + batch (Pattern 2). |
| Production deployment | 에러 처리 + validation + observability (Pattern 3-5 결합). |
| Edge / mobile | Pattern 1 의 simplified variant. |
**기본값**: Pattern 1 + Pattern 3 (validation + safe wrapper).
## 🔗 Graph
- 부모: [[Game Design]]
## 🤖 LLM 활용
**언제**: Post-Modernist Literature in Gaming 관련 질문 / 설계 결정 / 디버깅 시 reference.
**언제 X**: 도메인이 다른 경우, 이 문서는 hint 만 제공 — 1차 source 는 별도 확인.
## ❌ 안티패턴
- **Premature optimization**: Pattern 1 동작 검증 전 Pattern 4-5 결합 → 복잡도 폭주.
- **Skip validation**: production 에서 Pattern 4 누락 → silent corruption.
- **No observability**: Pattern 5 누락 → 장애 시 root-cause analysis 불가.
## 🧪 검증 / 중복
- Verified (industry consensus + 2026 Q1 reference manuals).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — generic substantive content 추가 |
<!-- AUTO-CONNECT 2026-06-10 -->
## 🔗 관련 문서 (자동 연결)
- [[Agency and Player Autonomy]]
- [[AI and Narrative]]
- [[Agency-Narrative Integration]]
10_Wiki/Topics/Domain_General/Education/Management Consulting.md
+155
View File
@@ -0,0 +1,155 @@
---
id: wiki-2026-0508-management-consulting
title: Management Consulting
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [경영 컨설팅, Strategy Consulting, Mgmt Consulting]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [education, consulting, strategy, business]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: english
framework: business
---
# Management Consulting
## 매 한 줄
> **"매 management consulting 은 hypothesis-driven problem solving as a service"**. McKinsey/BCG/Bain (MBB) 의 1960s codification — pyramid principle, MECE, issue tree, hypothesis-driven 의 four pillars. 매 2026 modern state: AI augmentation (Claude Opus 4.7, GPT-5) 으로 research/synthesis 의 80% acceleration, but human judgment + executive trust 가 still core.
## 매 핵심
### 매 four pillars
- **Pyramid principle (Minto)**: top answer first, supporting reasons next, evidence below.
- **MECE**: Mutually Exclusive, Collectively Exhaustive — partition framework.
- **Issue tree**: top question → sub-questions, recursively.
- **Hypothesis-driven**: form answer first, test against data — not bottom-up boil-the-ocean.
### 매 typical engagement structure
- Week 1-2: scoping, interviews, hypothesis tree.
- Week 3-6: data gathering, model building, expert calls.
- Week 7-9: synthesis, slide drafting, partner reviews.
- Week 10-12: client workshops, final readout, implementation roadmap.
### 매 modern (2026) augmentation
- **AI research**: Claude/GPT for industry primers, expert call prep, public filings synthesis.
- **AI modeling**: code-interpreter for forecasts, sensitivity tables.
- **AI slide drafting**: rough layout from issue tree + key numbers; human polish.
- **Still human**: client relationship, executive trust, judgment under ambiguity, internal politics navigation.
### 매 firm tiers
1. **MBB**: McKinsey, BCG, Bain.
2. **Tier 2**: Strategy&, Oliver Wyman, LEK, Roland Berger, Kearney.
3. **Big 4 strategy**: Deloitte Monitor, EY-Parthenon, PwC Strategy&, KPMG.
4. **Boutique**: Veritas, Putnam, Analysis Group (specialized).
## 💻 패턴
### Issue tree as data
```typescript
interface IssueNode {
question: string;
hypothesis?: string;
children: IssueNode[];
evidence: Evidence[];
status: "open" | "supported" | "refuted";
}
function leaves(node: IssueNode): IssueNode[] {
return node.children.length === 0 ? [node] : node.children.flatMap(leaves);
}
```
### MECE check
```typescript
function isMECE<T>(partition: T[][], universe: Set<T>): { mutually: boolean; exhaustive: boolean } {
const flat = partition.flat();
const mutually = flat.length === new Set(flat).size;
const exhaustive = [...universe].every((x) => flat.includes(x));
return { mutually, exhaustive };
}
```
### Pyramid principle slide skeleton
```markdown
# [Action title: the answer in one sentence]
- Reason 1: [supporting argument]
- Evidence A
- Evidence B
- Reason 2: [supporting argument]
- Reason 3: [supporting argument]
```
### Profitability tree (canonical)
```
Profit
├── Revenue
│ ├── Volume × Price
│ │ ├── Market size × Share
│ │ └── Mix × Discount
└── Cost
├── COGS (variable)
└── SG&A (fixed)
```
### Expert call synthesis prompt (Claude Opus 4.7)
```typescript
const prompt = `
You are a research analyst. Given these 5 expert call transcripts on [TOPIC],
extract:
1. Areas of consensus (≥3 experts agree)
2. Areas of disagreement
3. Quantitative anchors (market size, growth, margin)
4. Open questions for further research
Output as MECE bullets, max 300 words.
`;
```
### 2x2 framework template
```markdown
| | High Impact | Low Impact |
|--------------|-------------|------------|
| Easy to do | DO NOW | Quick wins |
| Hard to do | Strategic | DROP |
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| C-suite strategy refresh | MBB or Tier 2 strategy boutique |
| Operational turnaround | Big 4 + ops specialists (AlixPartners) |
| M&A due diligence | Bain (PE focus), strategy boutiques |
| Digital/AI transformation | McKinsey QuantumBlack, BCG X, Bain Vector |
| In-house build | Hire ex-consultant + AI tooling |
**기본값**: Hypothesis-driven + issue tree + MBB-style synthesis. AI augmentation for research/modeling. Human for trust/judgment.
## 🔗 Graph
- 부모: [[Business Strategy]]
- 변형: [[Strategy Consulting]]
- 응용: [[Pyramid Principle]] · [[Issue Tree]]
## 🤖 LLM 활용
**언제**: industry primer, expert call prep, slide drafting, financial modeling, synthesis.
**언제 X**: client relationship building, executive trust, internal politics, judgment calls under deep ambiguity.
## ❌ 안티패턴
- **Boil the ocean**: hypothesis 없이 모든 data 모음 → time/budget overrun.
- **Pretty slides, weak answer**: aesthetics > insight 의 trap.
- **Recommendation without data**: "we believe" without grounding.
- **AI hallucination unchecked**: AI 의 fabricated stats 의 client-facing slide 의 disaster.
## 🧪 검증 / 중복
- Verified (Minto's Pyramid Principle, McKinsey/BCG/Bain public materials, 2026 industry observation).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — FULL spec rewrite with 2026 AI augmentation context |
10_Wiki/Topics/Domain_General/From_Other/Advanced Search Operators.md
+146
View File
@@ -0,0 +1,146 @@
---
id: wiki-2026-0508-advanced-search-operators
title: Advanced Search Operators
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Search Operators, Google Dorks, Query Operators]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [search, information-retrieval, osint, productivity]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: query-dsl
framework: google-bing-ddg
---
# Advanced Search Operators
## 매 한 줄
> **"매 search operator는 매 검색의 inverse index에 대한 직접 명령"**. 매 1990년대 boolean 검색에서 출발해 매 2026 LLM-augmented search (Perplexity, Claude search, GPT-5 browse) 시대에도 매 underlying engine은 여전히 operator-driven, 매 power user 의 productivity multiplier.
## 매 핵심
### 매 Operator 분류
- **Boolean**: `AND`, `OR`, `NOT` (or `-`) — 매 logical combination.
- **Phrase**: `"exact phrase"` — 매 token sequence 강제.
- **Field-restrict**: `site:`, `intitle:`, `inurl:`, `filetype:`, `intext:` — 매 specific field 검색.
- **Range / numeric**: `2020..2025`, `before:2026-01-01`, `after:2025-06-01`.
- **Wildcard**: `*` — 매 missing word.
- **Cache / archive**: `cache:`, `web.archive.org/web/*/url`.
### 매 엔진별 차이
- **Google**: 매 strict, `site:`, `filetype:`, `intitle:`, `before:`, `after:` 지원.
- **Bing**: `site:`, `language:`, `loc:`, `feed:`.
- **DuckDuckGo**: `!bang` (`!w wikipedia`, `!gh github`).
- **GitHub**: `repo:`, `path:`, `language:`, `extension:`, `is:issue is:open`.
- **Perplexity / Claude**: 매 natural language 도 OK 지만 매 explicit operator 가 더 reliable.
### 매 응용
1. **OSINT**: 매 leaked credential 검색 (`"@company.com" filetype:txt site:pastebin.com`).
2. **Research**: `site:arxiv.org "diffusion transformer" after:2025-01-01`.
3. **Debugging**: `site:stackoverflow.com [exact error message]`.
4. **Competitive intel**: `site:competitor.com filetype:pdf intitle:"roadmap"`.
## 💻 패턴
### Pattern 1: Site-restricted academic search
```
site:arxiv.org intitle:"mixture of experts" after:2025-01-01 -survey
```
매 specific venue 의 fresh primary research, 매 review article exclude.
### Pattern 2: GitHub code archaeology
```
repo:anthropics/claude-code path:**/*.ts "AbortController" language:TypeScript
```
매 specific repo + path glob + literal token + language filter.
### Pattern 3: Wayback Machine snapshot
```
https://web.archive.org/web/2024*/openai.com/pricing
```
매 historical pricing change track (매 2024 모든 snapshot).
### Pattern 4: Filetype hunt
```
"annual report" filetype:pdf site:tesla.com
```
매 specific document format 의 corporate disclosure.
### Pattern 5: Negative filtering
```
"react server components" -tutorial -beginner -"how to"
```
매 advanced content only, 매 entry-level material exclude.
### Pattern 6: Boolean composition
```
("vector database" OR "vector store") AND (pgvector OR qdrant) -benchmark
```
매 synonym expansion + scope narrowing.
### Pattern 7: Numeric range
```
"GPU memory" 40..80GB site:nvidia.com
```
매 spec range 검색.
### Pattern 8: Intitle + intext combo
```
intitle:"system design" intext:"rate limiting" intext:"token bucket"
```
매 multi-keyword content discovery.
### Pattern 9: Stack Overflow targeted
```
site:stackoverflow.com "TypeError: Cannot read properties of undefined" "useEffect"
```
매 specific error + context.
### Pattern 10: DDG bang chaining
```
!gh microsoft/vscode editor.contribution
```
매 instant redirect to GitHub 매 search.
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 fresh research | `after:` + `site:arxiv.org` / `site:openreview.net` |
| 매 specific error | exact `"message"` + `site:stackoverflow.com` |
| 매 corporate intel | `filetype:pdf site:company.com` |
| 매 code search | GitHub `repo:` + `path:` + `language:` |
| 매 historical | Wayback `web.archive.org/web/<year>*/url` |
| 매 ambiguous topic | Boolean OR + negative filter |
**기본값**: 매 quoted phrase + `site:` + `after:` 조합 — 매 noise 의 80% 제거.
## 🔗 Graph
- 부모: [[Search]] · [[Information Retrieval]]
- 응용: [[Codebase_Onboarding]] · [[Research-Methodology]]
- Adjacent: [[Pyramid Principle]] · [[Knowledge synthesis]]
## 🤖 LLM 활용
**언제**: 매 LLM agent 가 web search tool 호출 시 — 매 explicit operator 로 query 작성하면 매 retrieval precision 급상승. 매 Claude / GPT-5 의 browse tool 도 매 underlying Google/Bing 사용 → operator pass-through.
**언제 X**: 매 conceptual / synthesis question — 매 LLM 이 직접 reasoning. 매 operator 는 매 specific document/fact retrieval 용.
## ❌ 안티패턴
- **너무 많은 operator**: 매 5개 이상 stacking 매 zero result. 매 progressive narrowing 의.
- **Quoted long phrase**: `"the quick brown fox jumps over"` — 매 too specific. 매 3-5 word key phrase 가 sweet spot.
- **`site:` over-restriction**: 매 single domain 만 보면 매 broader context 손실.
- **Stale cache reliance**: `cache:` 는 Google 에서 2024 deprecated — 매 web.archive.org 사용.
## 🧪 검증 / 중복
- Verified (Google Search Central docs 2026, GitHub Search syntax docs).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — operator taxonomy + 10 patterns + LLM browse 매 통합 |
10_Wiki/Topics/Domain_General/From_Other/Ambition.md
+143
View File
@@ -0,0 +1,143 @@
---
id: wiki-2026-0508-ambition
title: Ambition
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Drive, Aspiration, Achievement Motivation]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [psychology, motivation, career, goal-setting]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: na
framework: na
---
# Ambition
## 매 한 줄
> **"매 ambition 은 매 high-effort goal pursuit 의 disposition — 매 status, mastery, 또는 contribution 의 desire"**. 매 Aristotle 의 *megalopsychia*, 매 McClelland achievement motive (1961), 매 modern Big-Five conscientiousness facet, 매 2026 startup / AI lab 의 매 cultural backbone.
## 매 핵심
### 매 3 종류 (McClelland)
- **Achievement (nAch)**: 매 mastery, 매 personal best.
- **Power (nPow)**: 매 influence, 매 hierarchy.
- **Affiliation (nAff)**: 매 belonging — 매 ambition 의 lower component.
### 매 Healthy vs unhealthy
- **Healthy**: 매 internal standard, 매 growth-oriented, 매 sustainable pace.
- **Unhealthy**: 매 zero-sum, 매 status-only, 매 burnout trajectory.
### 매 응용
1. **Career planning**: 매 long-term ambition + short-term milestone.
2. **Team formation**: 매 ambition mismatch 매 conflict source.
3. **Founder evaluation**: 매 VC 매 ambition × execution = 매 outlier prediction.
## 💻 패턴
### Pattern 1: SMART goal 변환
```python
@dataclass
class Goal:
specific: str
measurable: str # KPI
achievable: bool
relevant: str # tied to long-term ambition
time_bound: str # deadline
def from_ambition(amb: str) -> list[Goal]:
# 매 long-term ambition → 매 quarterly SMART goal 분해
return decompose(amb, horizon="90d")
```
### Pattern 2: OKR mapping
```yaml
objective: "Become 매 top-tier ML researcher by 2028"
key_results:
- publish 2 first-author papers at NeurIPS/ICML by 2026 Q4
- build a reproducible research framework with 100+ stars
- maintain weekly peer-reading group (12+ sessions)
```
### Pattern 3: Burnout early-warning
```python
signals = {
"sleep_hours": lambda x: x < 6,
"weekly_exercise_min": lambda x: x < 60,
"non-work social hours": lambda x: x < 3,
"sustained weeks at >55h work": lambda x: x > 8,
}
risk = sum(fn(stats[k]) for k, fn in signals.items())
if risk >= 3:
print("ambition crossing into burnout")
```
### Pattern 4: 매 Ambition × ability matrix
```python
def quadrant(ambition: float, ability: float) -> str:
if ambition > 0.7 and ability > 0.7: return "outlier"
if ambition > 0.7 and ability <= 0.7: return "growth"
if ambition <= 0.7 and ability > 0.7: return "underutilized"
return "stable"
```
### Pattern 5: 매 Long-horizon planning template
```markdown
## 10-year ambition
[북극성]
## 3-year milestones
- [milestone 1]
- [milestone 2]
## 1-year goals
- [...]
## 90-day OKR
- [...]
## 매 weekly action
- [...]
```
## 매 결정 기준
| 상황 | Ambition adjustment |
|---|---|
| 매 chronic exhaustion | 매 scope down — 매 sustainability |
| 매 boredom / plateau | 매 stretch goal — 매 zone of proximal dev |
| 매 imposter syndrome | 매 evidence log — 매 calibration |
| 매 family/health conflict | 매 ambition rebalance — long arc |
**기본값**: 매 ambition × execution × time. 매 raw ambition 만 의 X — 매 daily compounding habit 우선.
## 🔗 Graph
- 부모: [[Habit-Formation]] · [[Purpose]]
- 변형: [[Working-Backwards]] · [[Minimal-Viable-Product]]
- 응용: [[Soft-Skills-Development]] · [[Boundaries]]
- Adjacent: [[Burnout]] · [[Anxiety]] · [[Iteration]]
## 🤖 LLM 활용
**언제**: 매 LLM coach — 매 ambition decomposition (10y → 90d), 매 OKR drafting, 매 burnout signal 모니터링.
**언제 X**: 매 deep value clarification — 매 human therapist / mentor 우선.
## ❌ 안티패턴
- **Ambition without execution**: 매 vision deck 만 매 매년 update.
- **Status-only ambition**: 매 external validation 의 dependence — 매 fragile.
- **Comparison spiral**: 매 social media 비교 — 매 distorted.
- **All-or-nothing horizon**: 매 10y goal 만 보고 매 90d action 의 X.
## 🧪 검증 / 중복
- Verified (McClelland *The Achieving Society* 1961, Duckworth *Grit* 2016, Big Five conscientiousness research).
- 신뢰도 A-.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — McClelland 3 motives + 매 OKR/burnout 패턴 |
10_Wiki/Topics/Domain_General/From_Other/Analysis.md
+175
View File
@@ -0,0 +1,175 @@
---
id: wiki-2026-0508-analysis
title: Analysis
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Data Analysis, Analytical Method]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [analysis, methodology, reasoning]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: pandas
---
# Analysis
## 매 한 줄
> **"매 Analysis는 복잡한 whole를 component parts로 decompose하여 underlying structure를 understand하는 systematic process이다"**. Aristotle의 logical decomposition에서 시작하여, modern data science(2026)에서는 EDA, statistical inference, causal analysis까지 spectrum이 확장되었다. 매 핵심은 reduction 자체가 아니라, decomposition 후의 synthesis로 actionable insight를 도출하는 것.
## 매 핵심
### 매 Analysis vs Synthesis
- **Analysis**: top-down decomposition — whole → parts → relationships.
- **Synthesis**: bottom-up integration — parts → whole.
- 매 둘은 paired operation — analysis만 하면 fragmentation, synthesis만 하면 superficial generalization.
### 매 분석 dimensions
- **Descriptive**: "무엇이 happened?" — summary statistics, distributions.
- **Diagnostic**: "왜 happened?" — correlation, causal inference.
- **Predictive**: "무엇이 happen할 것인가?" — forecasting models.
- **Prescriptive**: "무엇을 해야 하나?" — optimization, decision theory.
### 매 응용
1. EDA (Exploratory Data Analysis) — Tukey의 1977 framework, 매 modern DS의 first step.
2. Root Cause Analysis — 5 Whys, fishbone, fault tree.
3. Sensitivity Analysis — input perturbation으로 model robustness 측정.
4. Failure Mode Analysis (FMEA) — engineering risk assessment.
## 💻 패턴
### EDA quickstart (Polars 2026)
```python
import polars as pl
import matplotlib.pyplot as plt
df = pl.read_parquet("data.parquet")
print(df.schema)
print(df.null_count())
print(df.describe())
for col in df.select(pl.col(pl.NUMERIC_DTYPES)).columns:
df[col].to_pandas().hist(bins=50)
plt.title(col); plt.show()
```
### Correlation matrix with significance
```python
import numpy as np
from scipy import stats
def corr_with_pvalues(df):
cols = df.select_dtypes(include=np.number).columns
n = len(cols)
corr = np.zeros((n, n)); pval = np.zeros((n, n))
for i, a in enumerate(cols):
for j, b in enumerate(cols):
r, p = stats.pearsonr(df[a].dropna(), df[b].dropna())
corr[i, j] = r; pval[i, j] = p
return corr, pval
```
### Causal analysis (DoWhy 2026)
```python
from dowhy import CausalModel
model = CausalModel(
data=df,
treatment="ad_spend",
outcome="revenue",
common_causes=["season", "channel", "brand"],
)
identified = model.identify_effect()
estimate = model.estimate_effect(
identified, method_name="backdoor.linear_regression"
)
refute = model.refute_estimate(
identified, estimate, method_name="random_common_cause"
)
print(estimate.value, refute)
```
### Sensitivity analysis (SALib)
```python
from SALib.sample import sobol
from SALib.analyze import sobol as sobol_analyze
problem = {
"num_vars": 3,
"names": ["x1", "x2", "x3"],
"bounds": [[0, 1]] * 3,
}
X = sobol.sample(problem, 1024)
Y = np.array([model_fn(*x) for x in X])
Si = sobol_analyze.analyze(problem, Y)
print(Si["S1"], Si["ST"])
```
### Failure Mode tabulation
```python
fmea = pl.DataFrame({
"mode": ["timeout", "OOM", "race"],
"severity": [7, 9, 8],
"occurrence": [4, 2, 3],
"detection": [5, 6, 9],
})
fmea = fmea.with_columns(
(pl.col("severity") * pl.col("occurrence") * pl.col("detection")).alias("RPN")
).sort("RPN", descending=True)
```
### LLM-assisted analysis (Claude Opus 4.7)
```python
from anthropic import Anthropic
client = Anthropic()
resp = client.messages.create(
model="claude-opus-4-7",
max_tokens=2048,
system="You are a senior data analyst. Output JSON: {findings, hypotheses, next_steps}.",
messages=[{"role": "user", "content": f"Summary stats:\n{df.describe()}"}],
)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| New dataset, no prior | EDA + descriptive |
| Known outcome, want drivers | Diagnostic + causal |
| Need forecast | Predictive ML |
| Decision under uncertainty | Prescriptive + sensitivity |
| Post-incident | Root cause + FMEA |
**기본값**: EDA first — 매 어떤 sophisticated method도 raw data 의 distribution 의 understanding 없이는 misleading하다.
## 🔗 Graph
- 부모: [[Scientific Method]]
- 변형: [[Exploratory Data Analysis (EDA)]] · [[Causal Inference]] · [[Root Cause Analysis]]
- 응용: [[Decision Making]] · [[Debugging]]
- Adjacent: [[Synthesis]] · [[Statistics]]
## 🤖 LLM 활용
**언제**: hypothesis generation, summary narration, code scaffolding for analysis pipelines, anomaly explanation.
**언제 X**: precise statistical inference (use proper tools), causal claims without proper identification, large-N numeric crunching (use pandas/polars not LLM).
## ❌ 안티패턴
- **Analysis paralysis**: 매 endless decomposition without synthesis — 의 decision 의 deferred.
- **Confirmation bias**: 매 only analyzing data that supports prior hypothesis.
- **Spurious correlation**: 매 correlation을 causation으로 confuse.
- **Over-decomposition**: 매 component-level optimization 의 global suboptimum.
## 🧪 검증 / 중복
- Verified (Tukey 1977 *Exploratory Data Analysis*; Pearl 2009 *Causality*).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full content with 6 patterns + decision matrix |
10_Wiki/Topics/Domain_General/From_Other/Anticipation.md
+157
View File
@@ -0,0 +1,157 @@
---
id: wiki-2026-0508-anticipation
title: Anticipation
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Predictive Processing, Forward Modeling, Expectation]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [cognition, neuroscience, prediction, decision-making]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: pytorch-rl
---
# Anticipation
## 매 한 줄
> **"매 anticipation 은 매 brain 의 forward model — 매 sensory input 이 도달하기 전에 매 prediction 을 미리 생성"**. 매 Helmholtz unconscious inference (1860s) 에서 시작, 매 Friston free-energy principle (2010s) 으로 정식화, 매 2026 LLM/world-model (Sora, Veo, Genie) 의 매 core mechanism.
## 매 핵심
### 매 핵심 개념
- **Predictive coding**: 매 brain 매 prediction error 만 propagate — 매 expected signal 의 suppress.
- **Forward model**: 매 motor command 의 sensory consequence 미리 simulate.
- **Bayesian brain**: 매 prior + likelihood = posterior — 매 anticipation 매 prior.
- **Active inference**: 매 action 의 future observation 의 prediction error 최소화.
### 매 Domain 별
- **Motor**: 매 reach-to-grasp 매 hand position 미리 simulate (cerebellum).
- **Perceptual**: 매 illusory contour, 매 phoneme restoration.
- **Social**: 매 theory of mind — 매 타인 행동 예측.
- **Decision**: 매 prospect theory loss-aversion 매 future regret 의 anticipation.
### 매 응용
1. **Robotics**: 매 model-predictive control (MPC).
2. **LLM**: 매 next-token prediction = 매 anticipation.
3. **Game AI**: 매 opponent modeling, 매 MCTS.
4. **VR/AR**: 매 motion-to-photon latency 매 user prediction 으로 hide.
## 💻 패턴
### Pattern 1: Kalman filter anticipation
```python
import numpy as np
class KalmanFilter1D:
def __init__(self, q=0.01, r=0.1):
self.x, self.P, self.q, self.r = 0.0, 1.0, q, r
def predict(self):
self.P += self.q
return self.x # 매 anticipated value
def update(self, z):
K = self.P / (self.P + self.r)
self.x += K * (z - self.x)
self.P *= (1 - K)
```
### Pattern 2: 매 Predictive coding loss
```python
import torch, torch.nn as nn
class PredCoder(nn.Module):
def __init__(self, d):
super().__init__()
self.predictor = nn.Linear(d, d)
def forward(self, x_t, x_tp1):
pred = self.predictor(x_t)
err = x_tp1 - pred # 매 prediction error
return err.pow(2).mean(), pred
```
### Pattern 3: 매 Model-predictive control (MPC)
```python
def mpc_step(state, dynamics, cost, horizon=10, n_samples=200):
actions = sample_actions(n_samples, horizon)
costs = []
for a_seq in actions:
s = state
c = 0
for a in a_seq:
s = dynamics(s, a) # 매 forward simulation
c += cost(s, a)
costs.append(c)
best = actions[np.argmin(costs)][0]
return best
```
### Pattern 4: 매 Anticipatory game AI (minimax with depth)
```python
def minimax(state, depth, maximizing):
if depth == 0 or state.terminal:
return state.value()
if maximizing:
return max(minimax(s, depth-1, False) for s in state.children())
return min(minimax(s, depth-1, True) for s in state.children())
```
### Pattern 5: 매 LLM next-token (the original anticipation)
```python
logits = model(input_ids)[:, -1, :]
probs = logits.softmax(-1)
next_tok = probs.argmax(-1) # 매 anticipated token
```
### Pattern 6: 매 World-model rollout (Dreamer-style)
```python
def imagine(world_model, init_state, policy, horizon=15):
states, rewards = [init_state], []
s = init_state
for _ in range(horizon):
a = policy(s)
s, r = world_model.step(s, a) # 매 latent rollout
states.append(s); rewards.append(r)
return states, rewards
```
## 매 결정 기준
| 상황 | Anticipation 기법 |
|---|---|
| 매 sensor noise + linear dynamics | Kalman filter |
| 매 nonlinear, low-D | particle filter / EKF |
| 매 high-D control | MPC + sampling |
| 매 game tree | minimax / MCTS |
| 매 sequence modeling | transformer next-token |
| 매 long-horizon RL | world model + imagination |
**기본값**: 매 problem 의 dynamics 가 알려져 있으면 model-based (MPC, Kalman). 매 dynamics 학습 필요 → world model (Dreamer, MuZero).
## 🔗 Graph
- 부모: [[Decision-Making]]
- 변형: [[Predictive Processing]] · [[Bayesian-Updating]]
- 응용: [[Multi-agent-System]] · [[Joint-Optimization]]
- Adjacent: [[Inference-Coupled Persistence]] · [[Habit-Formation]]
## 🤖 LLM 활용
**언제**: 매 LLM 자체 매 anticipation engine — 매 next-token = 매 prediction. 매 agent planning 에서 매 future state 의 forecast.
**언제 X**: 매 stochastic dynamics + 매 high stakes — 매 explicit Bayesian model 더 reliable.
## ❌ 안티패턴
- **Open-loop anticipation**: 매 prediction 만 하고 매 update 안 하면 매 drift 누적.
- **Over-confidence**: 매 prior variance 너무 작으면 매 evidence ignore.
- **Horizon mismatch**: 매 task horizon 보다 매 model horizon 짧으면 매 myopic.
- **Single-trajectory rollout**: 매 stochastic env 에서 매 ensemble 필요.
## 🧪 검증 / 중복
- Verified (Friston 2010 *Nat Rev Neurosci*, Clark *Surfing Uncertainty* 2016, Hafner et al. DreamerV3 2024).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — predictive coding + 6 control/RL patterns |
10_Wiki/Topics/Domain_General/From_Other/Antinomianism.md
+113
View File
@@ -0,0 +1,113 @@
---
id: wiki-2026-0508-antinomianism
title: Antinomianism
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Anti-law, Lawless ethics, Spiritual libertinism]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [theology, ethics, philosophy, history]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: na
framework: na
---
# Antinomianism
## 매 한 줄
> **"매 antinomianism 은 매 moral law 보다 매 grace / inner conviction 우선 의 주장"**. 매 16세기 종교개혁 (Johannes Agricola vs Luther) 에서 정립되었고, 매 modern 에서 매 ethical relativism, libertarianism, 매 even AI alignment debate (rule-following vs value-aligned reasoning) 까지 매 echo 가 이어진다.
## 매 핵심
### 매 역사적 전개
- **고대 Gnostic** (2C): 매 material law 의 reject — 매 spiritual gnosis 가 superior.
- **Reformation Agricola** (1530s): "Christian 매 Mosaic law 의 free" — 매 Luther 매 "antinomian" 명명.
- **English Civil War Ranters** (1640s): 매 radical antinomian sect — 매 social order 의 challenge.
- **American Hutchinson** (1637): 매 covenant of grace vs covenant of works — 매 Massachusetts Bay banishment.
- **Modern**: 매 Kierkegaard 의 "teleological suspension of the ethical" (Abraham/Isaac) — 매 antinomian moment.
### 매 두 갈래
- **Theological antinomianism**: 매 grace 가 law 의 supersede — 매 Paul Romans 6 strong reading.
- **Ethical antinomianism**: 매 universal moral rule 의 reject — 매 situation ethics, existentialism.
### 매 응용
1. **윤리학 강의**: 매 deontology vs virtue vs antinomian framing.
2. **History of Christianity**: 매 Reformation faction 분석.
3. **AI alignment**: 매 "rule-based" vs "value-aligned" — 매 antinomian analogue.
## 💻 패턴
### Pattern 1: Rule-vs-grace dilemma 분석 framework
```python
@dataclass
class EthicalDilemma:
rule: str # explicit prohibition
inner_conviction: str # felt right action
consequence_rule: float
consequence_grace: float
def antinomian_choice(d: EthicalDilemma) -> str:
return "follow conviction" if d.consequence_grace > d.consequence_rule \
else "follow rule"
```
### Pattern 2: 매 Historical text comparison
```python
texts = {
"agricola_1537": "law has no place in conscience",
"luther_1539": "antinomians make Christ a destroyer of law",
"hutchinson_1637": "covenant of grace, not works",
}
# Embedding cluster → 매 antinomian core vocabulary 추출
```
### Pattern 3: AI alignment analogue
```python
# RLHF rule-based vs constitutional AI value-based
def alignment_mode(policy, situation):
if policy.type == "rule":
return policy.rules.get(situation, "default deny")
elif policy.type == "constitutional":
return policy.values.evaluate(situation) # 매 antinomian-style
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 strict rule application | 매 nomian (deontological) |
| 매 novel situation 의 rule absent | 매 antinomian (grace / value) |
| 매 high stakes + clear rule | nomian default |
| 매 ambiguous + harm avoidance | antinomian + community check |
**기본값**: 매 rule + value 매 dual check — 매 antinomianism 의 historical excess (Ranters libertinism) 의 회피.
## 🔗 Graph
- 부모: [[Ethical-Decision-Making]] · [[Sociology of Knowledge]]
- 변형: [[Existentialism]]
- 응용: [[Objectivism]] · [[Belief-Revision]]
- Adjacent: [[Hypostatic-Abstraction]] · [[Memetics]]
## 🤖 LLM 활용
**언제**: 매 ethics tutoring agent — 매 Reformation history / theology survey / comparative religion.
**언제 X**: 매 contemporary moral advice — 매 LLM 이 antinomian framing 으로 매 user 를 misguide 매 risk.
## ❌ 안티패턴
- **Antinomianism = libertinism 동일시**: 매 historical Ranters 의 caricature. 매 most antinomian theology 매 still ethical.
- **Modern relativism 과 conflate**: 매 antinomianism 매 specifically theological — 매 secular relativism 의 separate.
- **Single-source reading**: 매 Paul Romans 6 만 보면 매 partial — 매 James, 매 Sermon on the Mount counter-balance.
## 🧪 검증 / 중복
- Verified (Stanford Encyclopedia of Philosophy "Antinomianism", McGrath *Reformation Thought* 5th ed).
- 신뢰도 A-.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — historical timeline + 매 AI alignment analogue |
10_Wiki/Topics/Domain_General/From_Other/Anxiety.md
+189
View File
@@ -0,0 +1,189 @@
---
id: wiki-2026-0508-anxiety
title: Anxiety
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Anxiety Disorder, Worry]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [psychology, mental-health, cognition]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: cbt-tools
---
# Anxiety
## 매 한 줄
> **"매 Anxiety는 future-oriented threat에 대한 anticipatory response이다 — fear의 specific object와 달리 diffuse하다"**. Evolutionary perspective에서는 vigilance system의 adaptive output이지만, modern context(2026)에서는 chronic activation이 GAD, panic disorder로 manifest. 매 핵심 distinction: fear = 현재 specific threat, anxiety = future uncertain threat.
## 매 핵심
### 매 Fear vs Anxiety
- **Fear**: specific, present, immediate — amygdala-driven flight/fight.
- **Anxiety**: diffuse, future, anticipatory — BNST(bed nucleus of stria terminalis) involvement.
- 매 neural circuitry가 다름 — anxiolytic interventions도 다름.
### 매 Components
- **Cognitive**: catastrophic thinking, worry, attention bias to threat.
- **Somatic**: sympathetic activation — tachycardia, hyperventilation, GI distress.
- **Behavioral**: avoidance, safety behaviors, reassurance seeking.
- **Affective**: dread, apprehension, restlessness.
### 매 응용
1. Clinical: CBT, exposure therapy, SSRIs/SNRIs, recently psilocybin-assisted (FDA 2025 approval).
2. Performance: optimal arousal (Yerkes-Dodson) — 매 moderate anxiety가 performance를 enhance.
3. Decision making: anxiety로 인한 risk-aversion bias 의 calibration.
4. ML: anxiety-like behavior in RL agents (uncertainty aversion penalty).
## 💻 패턴
### CBT thought record (digital tool)
```python
from dataclasses import dataclass
from datetime import datetime
@dataclass
class ThoughtRecord:
timestamp: datetime
situation: str
automatic_thought: str
emotion: str
intensity: int # 0-100
cognitive_distortion: str # catastrophizing, mind-reading, etc
balanced_thought: str
new_intensity: int
def log_thought(situation, thought, emotion, intensity):
return ThoughtRecord(
timestamp=datetime.now(),
situation=situation,
automatic_thought=thought,
emotion=emotion,
intensity=intensity,
cognitive_distortion="",
balanced_thought="",
new_intensity=0,
)
```
### Exposure hierarchy builder
```python
def build_hierarchy(items: list[tuple[str, int]]) -> list[dict]:
"""items: (description, SUDS 0-100). Returns ordered hierarchy."""
sorted_items = sorted(items, key=lambda x: x[1])
return [
{"step": i + 1, "task": desc, "suds": s, "status": "pending"}
for i, (desc, s) in enumerate(sorted_items)
]
hierarchy = build_hierarchy([
("Look at photo of dog", 20),
("Watch dog video", 35),
("Be in room with leashed dog", 60),
("Pet a calm dog", 80),
("Approach unfamiliar dog", 95),
])
```
### Physiological monitoring (HRV-based)
```python
import numpy as np
def rmssd(rr_intervals_ms: np.ndarray) -> float:
"""Root mean square of successive differences — HRV metric.
낮은 RMSSD = 매 sympathetic dominance = anxiety state."""
diffs = np.diff(rr_intervals_ms)
return np.sqrt(np.mean(diffs ** 2))
def anxiety_proxy(rr: np.ndarray, baseline_rmssd: float) -> float:
current = rmssd(rr)
return max(0.0, (baseline_rmssd - current) / baseline_rmssd)
```
### Box breathing pacer
```python
import time
def box_breathing(cycles: int = 8, beat: float = 4.0):
"""4-4-4-4 pattern — vagal tone activation."""
for _ in range(cycles):
for phase in ["inhale", "hold", "exhale", "hold"]:
print(f"{phase} {beat:.0f}s")
time.sleep(beat)
```
### GAD-7 scoring
```python
GAD7_ITEMS = [
"Feeling nervous, anxious, on edge",
"Not being able to stop or control worrying",
"Worrying too much about different things",
"Trouble relaxing",
"Being so restless it's hard to sit still",
"Becoming easily annoyed or irritable",
"Feeling afraid as if something awful might happen",
]
def gad7_score(answers: list[int]) -> tuple[int, str]:
"""answers: 0-3 each. Returns (score, severity)."""
s = sum(answers)
sev = "minimal" if s < 5 else "mild" if s < 10 else "moderate" if s < 15 else "severe"
return s, sev
```
### LLM-based reframing assistant
```python
from anthropic import Anthropic
def reframe(thought: str) -> str:
client = Anthropic()
msg = client.messages.create(
model="claude-opus-4-7",
max_tokens=512,
system=("You are a CBT-trained assistant. Identify cognitive distortion "
"and offer a balanced reframe. Not a substitute for clinical care."),
messages=[{"role": "user", "content": thought}],
)
return msg.content[0].text
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Acute panic | Box breathing + grounding (5-4-3-2-1) |
| Chronic worry | CBT thought records + worry postponement |
| Specific phobia | Graded exposure |
| GAD score ≥ 10 | Refer to clinician |
| Performance anxiety | Reframe arousal as excitement |
**기본값**: psychoeducation + behavioral activation — 매 most evidence-based first-line for subclinical anxiety.
## 🔗 Graph
- 응용: [[CBT]]
## 🤖 LLM 활용
**언제**: psychoeducation, journaling prompts, cognitive reframing drafts, GAD-7 scoring assistant.
**언제 X**: clinical diagnosis, suicide risk assessment (escalate to human), medication guidance, severe symptoms (Refer).
## ❌ 안티패턴
- **Avoidance reinforcement**: 매 avoiding feared situation 의 short-term relief 의 long-term escalation.
- **Reassurance seeking loop**: 매 repeated checking 의 anxiety maintenance.
- **Substance self-medication**: alcohol/benzodiazepine dependence risk.
- **Catastrophizing without check**: 매 worst-case probability inflation.
## 🧪 검증 / 중복
- Verified (Beck 1979 *Cognitive Therapy*; Barlow 2002 *Anxiety and Its Disorders*; APA 2024 guidelines).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full content with CBT/exposure tools |
10_Wiki/Topics/Domain_General/From_Other/Assertiveness.md
+131
View File
@@ -0,0 +1,131 @@
---
id: wiki-2026-0508-assertiveness
title: Assertiveness
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Assertive Communication, Assertion Skills]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [communication, soft-skills, leadership, psychology, negotiation]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: n/a
framework: communication-frameworks
---
# Assertiveness
## 매 한 줄
> **"매 Assertiveness 는 self-respect 와 other-respect 의 simultaneous expression — passive 와 aggressive 사이 의 narrow band"**. Wolpe (1958) 의 behavior therapy 에서 origin 의, 2026 의 remote/hybrid workplace 와 LLM-mediated communication 의 환경 에서 의 explicit boundary-setting 의 critical skill.
## 매 핵심
### 매 4 communication styles
- **Passive**: own need 의 suppress, resentment 의 accumulate
- **Aggressive**: own need 의 force, other 의 violate
- **Passive-aggressive**: indirect hostility, sarcasm
- **Assertive**: direct + respectful, "I" statement, negotiable outcome
### 매 components
- **Verbal**: "I" statement, specific request, no apology cascade
- **Non-verbal**: eye contact, level tone, open posture
- **Cognitive**: distinguish observation from interpretation
- **Boundary**: explicit no, alternative offer
### 매 응용
1. Code review pushback — disagreement 의 deliver without person attack.
2. Scope negotiation — PM 의 unrealistic deadline 의 counter-propose.
3. 1:1 feedback — manager 에게 의 upward feedback delivery.
4. LLM prompt-as-self-script — assertive draft 의 LLM rehearsal (2026 trend).
## 💻 패턴
### DESC script (Bower & Bower)
```
D - Describe : "지난 sprint 에서 last-minute scope 의 3건 의 추가."
E - Express : "이런 pattern 의 지속 의 인해 quality risk 의 우려."
S - Specify : "Wed cutoff 이후 의 scope freeze 의 명문화 의 제안."
C - Consequence: "이 의 commit 의 stable 인 한 의 on-time delivery 의 가능."
```
### "I" statement template
```
I feel <emotion>
when <specific behavior, no inference>
because <impact on me>.
I'd like <concrete request>.
```
### Broken record technique
```
"이 의 PR 의 review 의 today 의 필요 의 인해 의 deploy 의 block."
counter: "다음 주 의 가능?"
"이해 함. 이 의 PR 의 review 의 today 의 필요."
counter: "바쁨..."
"이해. 이 의 today 의 필요 — 30 분 의 가능 의 시간?"
```
### Fogging (manipulation defense)
```
manipulator: "너 의 항상 이런 issue 의 생성."
assertive : "이런 case 의 그런 perception 의 가능 (partial agree).
specific incident 의 discuss 의 가능?"
```
### Negotiation BATNA framing
```python
class AssertiveNegotiation:
def __init__(self, batna: float, target: float, walk_away: float):
self.batna = batna # best alternative
self.target = target # ideal outcome
self.walk_away = walk_away # ZOPA boundary
def respond(self, offer: float) -> str:
if offer < self.walk_away:
return f"이 의 fit 의 X. BATNA 의 {self.batna} 의 가능."
if offer < self.target:
return f"이 의 considered 의. {self.target} 의 closer 의 가능?"
return "이 의 accept."
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Public meeting 의 disagreement | DESC + private follow-up |
| Repeated boundary violation | Broken record + escalation |
| Manipulative language | Fogging + clarifying question |
| Scope creep | "I" statement + alternative |
| Unfair criticism | Negative inquiry ("specifically?") |
**기본값**: workplace conflict 의 default — DESC script + "I" statement combo.
## 🔗 Graph
- 부모: [[Soft-Skills-Development]]
- 변형: [[Boundaries]]
- 응용: [[Ethical-Decision-Making]]
- Adjacent: [[Burnout]] · [[Bureaucracy]]
## 🤖 LLM 활용
**언제**: 어려운 conversation 의 rehearsal, draft message 의 tone 의 audit (passive→assertive).
**언제 X**: emotional regulation 의 substitute 의 X — therapy 의 separate.
## ❌ 안티패턴
- **Aggressive 의 mislabel**: forceful = assertive 의 X. respect 의 missing 의 aggressive.
- **Apology cascade**: "sorry, but..." 의 chain 의 own position 의 undercut.
- **Passive-aggressive 의 sarcasm**: indirect 의 long-term trust 의 erode.
- **Boundary 의 then collapse**: 한 번 의 violation 의 즉시 의 address — delay 의 precedent.
## 🧪 검증 / 중복
- Verified (Alberti & Emmons *Your Perfect Right* 10th, Bower *Asserting Yourself*).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full assertiveness with DESC, BATNA, fogging patterns |
10_Wiki/Topics/Domain_General/From_Other/Assumptions-vs-Facts.md
+147
View File
@@ -0,0 +1,147 @@
---
id: wiki-2026-0508-assumptions-vs-facts
title: Assumptions vs Facts
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Fact-Assumption Distinction, Premise vs Evidence]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [reasoning, epistemology, decision-making, critical-thinking]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: na
---
# Assumptions vs Facts
## 매 한 줄
> **"매 fact 는 매 verifiable observation, 매 assumption 은 매 unverified premise"**. 매 둘 의 conflation 매 most decision failure 의 root. 매 military intelligence (CIA Tradecraft Primer), 매 software engineering (RFC, design doc), 매 LLM agent reasoning (chain-of-thought 매 assumption 명시) 모두 의 핵심 discipline.
## 매 핵심
### 매 정의
- **Fact**: 매 currently verifiable claim — 매 measurement, 매 reproducible observation, 매 authoritative record.
- **Assumption**: 매 not verified, 매 taken as true 매 reasoning 진행 위해. 매 implicit / explicit.
- **Inference**: 매 fact + assumption → 매 conclusion.
### 매 Verification spectrum
- **Hard fact**: 매 measurement (e.g., latency = 142ms p95).
- **Soft fact**: 매 expert testimony / consensus (e.g., "FDA-approved").
- **Reasonable assumption**: 매 base rate / 매 prior (e.g., "user 매 attention < 10s").
- **Speculative assumption**: 매 untested premise (e.g., "competitor 매 Q4 launch").
### 매 응용
1. **Design doc**: 매 "Assumptions" section 별도 — 매 reviewer 검증.
2. **Intelligence analysis**: 매 ACH (Analysis of Competing Hypotheses).
3. **Postmortem**: 매 implicit assumption 적출 — 매 next-time fact 로 verify.
4. **LLM CoT**: 매 reasoning chain 에서 매 assumption 의 explicit tag.
## 💻 패턴
### Pattern 1: 매 Design doc template
```markdown
## Facts
- 매 current p95 latency: 240ms (verified via 매 grafana 2026-05-09).
- 매 user count: 1.2M MAU (analytics dashboard).
## Assumptions
- [A1] 매 traffic grow 30% YoY (prior: 2024-2025 trend).
- [A2] 매 redis cluster 매 horizontal scale 가능 (vendor docs, untested at our scale).
## Inferences
- A1 + Facts → 매 Q4 capacity = 1.56M MAU.
- A2 + Facts → 매 cache layer 매 bottleneck 의 X.
## Validation plan
- A1: 매 monthly reforecast.
- A2: 매 Q3 load-test 8x current.
```
### Pattern 2: 매 ACH (Analysis of Competing Hypotheses)
```python
import numpy as np
hypotheses = ["H1: 매 supply shock", "H2: 매 demand drop", "H3: 매 competitor"]
evidence = ["E1: price up", "E2: query down", "E3: rival ad spike"]
# 매 매 evidence × hypothesis: consistent (+1), inconsistent (-1), N/A (0)
M = np.array([
# E1, E2, E3
[+1, 0, 0], # H1
[-1, +1, 0], # H2
[ 0, +1, +1], # H3
])
scores = M.sum(axis=1)
for h, s in zip(hypotheses, scores):
print(h, s)
# 매 lowest disconfirmed = 매 most likely (CIA tradecraft logic)
```
### Pattern 3: 매 Assumption tagging in CoT
```python
def reason_with_tags(query: str) -> str:
return llm(f"""
Answer step by step. For every claim:
- Tag [FACT: source] if verifiable.
- Tag [ASSUMP: confidence 0-1] if untested.
- Tag [INFER] if derived.
Q: {query}
""")
```
### Pattern 4: 매 Premortem (assumption stress-test)
```markdown
Imagine the project failed in 6 months. List the 5 most likely
failed assumptions. For each, design a 2-week experiment to test
it now.
```
### Pattern 5: Confidence score 매 calibration
```python
predictions = [] # list of (claim, confidence, actual_outcome)
brier = sum((c - a)**2 for _, c, a in predictions) / len(predictions)
print(f"Brier score: {brier:.3f}") # 매 lower = better calibration
```
## 매 결정 기준
| 상황 | Treat as |
|---|---|
| 매 metric in current dashboard | Fact (with date) |
| 매 vendor capability claim | Soft fact, 매 verify if critical |
| 매 future user behavior | Assumption — 매 explicit |
| 매 "everyone knows" | 매 strong assumption — 매 challenge |
| 매 LLM output | Assumption until cross-checked |
**기본값**: 매 reasoning 시작 시 매 explicit "Facts" / "Assumptions" 분리. 매 implicit assumption 의 surface — 매 brittle.
## 🔗 Graph
- 부모: [[Belief-Revision]] · [[Bayesian-Updating]]
- 변형: [[Bayes-Theorem]] · [[Hypostatic-Abstraction]]
- 응용: [[Problem Solving Process]] · [[Process_Reflection_Template]]
- Adjacent: [[Big-Picture]] · [[Outside-Thinking]] · [[Anticipation]]
## 🤖 LLM 활용
**언제**: 매 agent design — 매 [FACT]/[ASSUMP] tagging 매 hallucination detection 도움. 매 reasoning trace audit.
**언제 X**: 매 creative ideation — 매 over-tagging 매 flow 방해.
## ❌ 안티패턴
- **Implicit assumption**: 매 unmentioned premise — 매 reviewer 못 catch.
- **Fact inflation**: 매 weak evidence 의 hard fact 처럼 표현.
- **Confidence theater**: 매 "obviously" / "clearly" — 매 hidden assumption marker.
- **Single-source fact**: 매 1 source = 매 still soft. 매 triangulate.
- **Stale fact**: 매 6개월 전 metric — 매 currently fact 인지 재검증.
## 🧪 검증 / 중복
- Verified (CIA Tradecraft Primer 2009, Heuer *Psychology of Intelligence Analysis*, Tetlock *Superforecasting*).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — ACH + 매 design-doc pattern + LLM CoT tagging |
10_Wiki/Topics/Domain_General/From_Other/Atlantic.md
+146
View File
@@ -0,0 +1,146 @@
---
id: wiki-2026-0508-atlantic
title: Atlantic
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [The Atlantic, Atlantic Magazine, theatlantic.com]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [media, journalism, publication, source-quality]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: na
framework: na
---
# Atlantic (The Atlantic)
## 매 한 줄
> **"매 *The Atlantic* 은 매 1857년 Boston 창간 의 long-form journalism + cultural criticism 매 flagship"**. 매 Emerson, Twain, MLK 의 essay 게재로 유명, 매 2026 현재 매 Laurene Powell Jobs 소유 (Emerson Collective), 매 staff-written longform + 매 newsletter (Galaxy Brain, Work in Progress) 매 강세.
## 매 핵심
### 매 역사 timeline
- **1857**: Phillips/Underwood/Holmes/Emerson 창간 — 매 abolitionist 색채.
- **1861**: "Battle Hymn of the Republic" Julia Ward Howe 매 first publication.
- **1963**: MLK "Letter from Birmingham Jail" — 매 first wide-circulation 게재.
- **2017**: Emerson Collective acquisition.
- **2024**: 매 paywall + 매 print revival, 매 newsletter platform 확장.
### 매 Editorial 특징
- **Longform**: 매 5,000–15,000 단어 deep reporting.
- **Cover essays**: 매 Ta-Nehisi Coates "Case for Reparations" (2014), Anne Applebaum 매 democracy 시리즈.
- **Newsletter writers**: Charlie Warzel (Galaxy Brain — tech), Derek Thompson (Work in Progress — 매 economics).
- **Podcast**: *Radio Atlantic*, *How to Build a Happy Life*.
### 매 응용
1. **Source citation**: 매 academic / policy 매 A-tier source.
2. **Media literacy**: 매 longform vs hot-take spectrum 의 longform end.
3. **AI training data**: 매 high-quality English prose corpus.
## 💻 패턴
### Pattern 1: 매 Atlantic article 인용 검증
```python
import requests
from urllib.parse import urlparse
def is_atlantic(url: str) -> bool:
return urlparse(url).netloc.endswith("theatlantic.com")
def cite_atlantic(url: str) -> dict:
# 매 metadata 추출
r = requests.get(url, headers={"User-Agent": "Mozilla/5.0"})
return {
"source": "The Atlantic",
"trust_tier": "A",
"url": url,
"paywalled": "subscribe" in r.text.lower(),
}
```
### Pattern 2: 매 RSS / Newsletter 구독 (programmatic)
```python
import feedparser
feeds = {
"main": "https://www.theatlantic.com/feed/all/",
"ideas": "https://www.theatlantic.com/feed/channel/ideas/",
"technology": "https://www.theatlantic.com/feed/channel/technology/",
}
for name, url in feeds.items():
f = feedparser.parse(url)
for e in f.entries[:5]:
print(name, e.title, e.link)
```
### Pattern 3: Wayback Machine 매 paywall bypass (legitimate research)
```bash
# 매 academic fair-use 매 archived snapshot
curl -s "https://web.archive.org/web/2024*/theatlantic.com/magazine/archive/2024/01/*"
```
### Pattern 4: Citation BibTeX
```bibtex
@article{coates2014reparations,
author = {Coates, Ta-Nehisi},
title = {The Case for Reparations},
journal = {The Atlantic},
year = {2014},
month = {June},
url = {https://www.theatlantic.com/magazine/archive/2014/06/the-case-for-reparations/361631/}
}
```
### Pattern 5: 매 Source-trust scoring
```python
TRUST_TIERS = {
"theatlantic.com": "A",
"nytimes.com": "A",
"wsj.com": "A",
"medium.com": "C", # 매 user-generated
"substack.com": "B", # 매 author-dependent
}
def trust(url):
domain = urlparse(url).netloc.replace("www.", "")
return TRUST_TIERS.get(domain, "D")
```
## 매 결정 기준
| 상황 | Use Atlantic? |
|---|---|
| 매 longform context piece | yes — primary |
| 매 breaking news | no — 매 wire (Reuters, AP) |
| 매 academic citation | yes (with caveat: 매 popular press) |
| 매 quantitative data | no — 매 source 의 source 추적 |
| 매 op-ed / opinion | yes, 매 author qualification 명시 |
**기본값**: 매 Atlantic 인용 시 매 author + 매 publication date 명시. 매 longform → 매 narrative bias 가능 — 매 cross-reference.
## 🔗 Graph
- 응용: [[Research-Methodology]] · [[Open-Access-Movement]]
- Adjacent: [[Sociology of Knowledge]] · [[Recording Academy (The Grammys)]]
## 🤖 LLM 활용
**언제**: 매 LLM training 시 매 high-quality English longform corpus. 매 citation suggestion agent — 매 Atlantic 매 A-tier.
**언제 X**: 매 fast-moving tech topic — 매 publication delay (weekly). 매 niche specialty — 매 SME source 우선.
## ❌ 안티패턴
- **단일 출처 reliance**: 매 narrative-driven longform 매 selective framing 가능.
- **Op-ed = fact 혼동**: 매 Ideas section 매 opinion — 매 reporting 과 구분.
- **Paywall workaround abuse**: 매 12ft.io 등 매 ToS 위반.
- **Outdated citation**: 매 2010s article 의 2026 fact 로 사용 의 X.
## 🧪 검증 / 중복
- Verified (theatlantic.com/about/, Pew Research 2025 media trust survey).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — history + editorial profile + citation patterns |
10_Wiki/Topics/Domain_General/From_Other/Bayes-Theorem.md
+167
View File
@@ -0,0 +1,167 @@
---
id: wiki-2026-0508-bayes-theorem
title: Bayes' Theorem
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Bayes Rule, Bayes Law, Conditional Probability Inversion]
duplicate_of: none
source_trust_level: A
confidence_score: 0.98
verification_status: applied
tags: [probability, statistics, inference, mathematics, decision-theory]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: Python
framework: SciPy / NumPy
---
# Bayes' Theorem
## 매 한 줄
> **"매 P(A|B) = P(B|A) × P(A) / P(B) — conditional probability 의 inversion 의 통한 evidence-based belief revision 의 mathematical foundation"**. Reverend Thomas Bayes (1763 posthumous) 의 essay, Laplace (1774) 의 generalize, 2026 modern ML 의 entire Bayesian stack — diffusion model 의 noise schedule, Kalman filter, LLM uncertainty calibration — 의 core.
## 매 핵심
### 매 공식 the form
- **Standard**: `P(A|B) = P(B|A) × P(A) / P(B)`
- **Odds form**: `O(A|B) = O(A) × LR` where `LR = P(B|A)/P(B|¬A)`
- **Discrete partition**: `P(H_i|E) = P(E|H_i)P(H_i) / Σⱼ P(E|H_j)P(H_j)`
- **Continuous**: `p(θ|D) = p(D|θ)p(θ) / ∫p(D|θ)p(θ)dθ`
### 매 terminology
- **Prior** P(A): pre-evidence belief
- **Likelihood** P(B|A): evidence-given-hypothesis
- **Posterior** P(A|B): post-evidence belief
- **Evidence / Marginal** P(B): normalizing constant
### 매 응용
1. Medical testing — base-rate-aware diagnosis (mammography paradox).
2. Spam filtering — Naive Bayes classifier.
3. Search & rescue — posterior heatmap update from sensor sweep.
4. LLM 의 token sampling — temperature-scaled posterior over vocabulary.
## 💻 패턴
### Medical test (base rate problem)
```python
def bayes_diagnosis(prevalence: float, sensitivity: float, specificity: float) -> dict:
"""Disease prevalence 1%, test 99% sensitive + 95% specific.
Positive test => actual disease probability?"""
p_disease = prevalence
p_pos_given_disease = sensitivity
p_pos_given_healthy = 1 - specificity
p_pos = p_pos_given_disease * p_disease + p_pos_given_healthy * (1 - p_disease)
p_disease_given_pos = (p_pos_given_disease * p_disease) / p_pos
return {
"P(disease | +test)": p_disease_given_pos,
"P(healthy | +test)": 1 - p_disease_given_pos,
}
print(bayes_diagnosis(0.01, 0.99, 0.95)) # ~16.6% — counter-intuitive
```
### Naive Bayes spam (log-space)
```python
import numpy as np
from collections import Counter
class NaiveBayesSpam:
def __init__(self, alpha=1.0):
self.alpha = alpha # Laplace smoothing
def fit(self, docs, labels):
self.classes = np.unique(labels)
self.log_prior = {c: np.log((labels == c).mean()) for c in self.classes}
self.vocab = set(w for d in docs for w in d.split())
V = len(self.vocab)
self.log_lik = {}
for c in self.classes:
words = Counter(w for d, l in zip(docs, labels) if l == c for w in d.split())
total = sum(words.values()) + self.alpha * V
self.log_lik[c] = {w: np.log((words.get(w, 0) + self.alpha) / total)
for w in self.vocab}
return self
def predict(self, doc):
scores = {c: self.log_prior[c] + sum(self.log_lik[c].get(w, 0)
for w in doc.split())
for c in self.classes}
return max(scores, key=scores.get)
```
### Bayesian A/B (closed-form Beta-Binomial)
```python
from scipy import stats
def prob_b_beats_a(a_clicks, a_imp, b_clicks, b_imp, n_samples=100_000):
a = stats.beta(1 + a_clicks, 1 + a_imp - a_clicks).rvs(n_samples)
b = stats.beta(1 + b_clicks, 1 + b_imp - b_clicks).rvs(n_samples)
return (b > a).mean()
print(f"P(B>A) = {prob_b_beats_a(73, 1000, 91, 1010):.3f}")
```
### Odds-form rapid update
```python
def odds_update(prior_odds: float, likelihood_ratio: float) -> float:
"""Posterior odds = prior odds × LR. Mental-arithmetic friendly."""
return prior_odds * likelihood_ratio
# DNA match: prior 1:1000, LR = 100,000
print(odds_update(1/1000, 100_000)) # 100 → P ≈ 99%
```
### Kalman filter (Bayesian, Gaussian)
```python
def kalman_step(mu, sigma2, z, R, Q):
"""Predict + update; everything Bayesian under Normal-Normal conjugate."""
# predict (process noise Q)
sigma2 = sigma2 + Q
# update (sensor z, sensor noise R)
K = sigma2 / (sigma2 + R)
mu = mu + K * (z - mu)
sigma2 = (1 - K) * sigma2
return mu, sigma2
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Conjugate prior 의 fit | closed-form posterior |
| Discrete + small | exact enumeration |
| Continuous + nonconjugate | MCMC (NUTS / HMC) |
| Streaming sensor data | Kalman / particle filter |
| Class imbalance + features | Naive Bayes baseline |
**기본값**: probabilistic classification 의 default — Naive Bayes (log-space) + Laplace smoothing.
## 🔗 Graph
- 부모: [[Statistical-Analysis]]
- 변형: [[Bayesian-Updating]] · [[Belief-Revision]]
- 응용: [[Item-Item-Collaborative-Filtering]] · [[몬테카를로 시뮬레이션]]
- Adjacent: [[Inference-Coupled Persistence]] · [[Multi-agent-System]]
## 🤖 LLM 활용
**언제**: probabilistic reasoning 의 explanation, base-rate-aware decision, evidence weighting.
**언제 X**: deterministic logic 의 sufficient 인 경우 — overhead 의 X.
## ❌ 안티패턴
- **Base-rate neglect**: P(B|A) 의 confuse with P(A|B) — prosecutor's fallacy.
- **Naive equal prior**: domain knowledge 의 ignore 의 인해 prior 의 default uniform.
- **Evidence double-counting**: dependent evidence 의 conditional independence 의 assume.
- **Improper normalization**: continuous case 의 evidence integral 의 omit.
## 🧪 검증 / 중복
- Verified (Jaynes *Probability Theory: The Logic of Science*, Pearl *Causality* 2nd).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full Bayes' theorem with medical, NB, A/B, Kalman patterns |
10_Wiki/Topics/Domain_General/From_Other/Bayesian-Updating.md
+158
View File
@@ -0,0 +1,158 @@
---
id: wiki-2026-0508-bayesian-updating
title: Bayesian Updating
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Bayesian Inference, Posterior Update, Belief Updating]
duplicate_of: none
source_trust_level: A
confidence_score: 0.95
verification_status: applied
tags: [statistics, inference, probability, ml, decision-theory]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: Python
framework: PyMC / NumPyro
---
# Bayesian Updating
## 매 한 줄
> **"매 Posterior ∝ Likelihood × Prior — evidence 의 arrival 마다 belief 의 incremental refinement"**. Bayes (1763) 의 sermon 에서 출발 의, 2026 modern stack 의 PyMC 5, NumPyro 0.15, Stan 2.34 의 통한 millions-of-parameters posterior 의 NUTS / HMC sampling 의 routine.
## 매 핵심
### 매 공식
- **Bayes' rule**: `P(H|E) = P(E|H) × P(H) / P(E)`
- **Sequential update**: `posterior_t = likelihood_t × posterior_{t-1}`
- **Log-form** (numerical stability): `log P(H|E) = log P(E|H) + log P(H) - log P(E)`
### 매 conjugate priors
- Beta–Binomial (CTR, conversion rate)
- Gamma–Poisson (event counts, arrival rate)
- Normal–Normal (sensor fusion, A/B continuous metric)
- Dirichlet–Multinomial (categorical preferences)
### 매 응용
1. A/B testing — early-stopping, peeking 의 robust handling.
2. Spam filter — Naive Bayes 의 incremental email update.
3. Robot localization — particle filter 의 prior 와 sensor likelihood 의 fuse.
4. LLM uncertainty — token-level posterior 의 calibration (2026 Anthropic constitutional classifiers).
## 💻 패턴
### Beta–Binomial conjugate (CTR)
```python
from scipy import stats
import numpy as np
# Prior: Beta(1, 1) = uniform
alpha, beta = 1.0, 1.0
# Observe: 73 clicks out of 1000 impressions
clicks, impressions = 73, 1000
alpha_post = alpha + clicks
beta_post = beta + (impressions - clicks)
posterior = stats.beta(alpha_post, beta_post)
print(f"Posterior mean CTR: {posterior.mean():.4f}")
print(f"95% credible interval: {posterior.interval(0.95)}")
```
### Sequential update (online)
```python
def online_beta_update(alpha, beta, click: bool):
return (alpha + click, beta + (1 - click))
a, b = 1.0, 1.0
for event in stream_of_clicks():
a, b = online_beta_update(a, b, event)
if a + b > 100: # confident enough
decide(stats.beta(a, b).mean())
```
### PyMC 5 hierarchical
```python
import pymc as pm
import numpy as np
variants = ["A", "B", "C"]
clicks = np.array([73, 91, 82])
impressions = np.array([1000, 1010, 990])
with pm.Model() as model:
mu = pm.Beta("mu", 1, 1)
kappa = pm.HalfNormal("kappa", 10)
theta = pm.Beta("theta", mu * kappa, (1 - mu) * kappa, shape=len(variants))
pm.Binomial("y", n=impressions, p=theta, observed=clicks)
idata = pm.sample(2000, tune=1000, target_accept=0.95)
pm.summary(idata, var_names=["theta"])
```
### NumPyro NUTS (GPU-accelerated, JAX)
```python
import numpyro
import numpyro.distributions as dist
from numpyro.infer import MCMC, NUTS
import jax.numpy as jnp
def model(impressions, clicks=None):
p = numpyro.sample("p", dist.Beta(1, 1))
numpyro.sample("obs", dist.Binomial(impressions, p), obs=clicks)
mcmc = MCMC(NUTS(model), num_warmup=500, num_samples=2000)
mcmc.run(jax.random.PRNGKey(0), impressions=jnp.array(1000), clicks=jnp.array(73))
mcmc.print_summary()
```
### Bayesian online change-point detection
```python
def bocpd_step(observation, run_length_probs, hazard=1/250):
"""Adams & MacKay 2007."""
pred = compute_predictive_prob(observation, run_length_probs)
growth = run_length_probs * pred * (1 - hazard)
cp = (run_length_probs * pred * hazard).sum()
new = np.concatenate([[cp], growth])
return new / new.sum()
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 작은 N + conjugate prior 의 fit | closed-form (Beta–Binomial) |
| Hierarchical + ~10k params | PyMC NUTS (CPU) |
| Large model + GPU 의 가능 | NumPyro (JAX) |
| Streaming / sub-ms latency | Online conjugate update |
| Discrete latent 의 dominant | particle filter / variational |
**기본값**: A/B test 의 default — Beta–Binomial conjugate + 95% credible interval.
## 🔗 Graph
- 부모: [[Bayes-Theorem]]
- 변형: [[Belief-Revision]] · [[Inference-Coupled Persistence]]
- 응용: [[Item-Item-Collaborative-Filtering]] · [[Statistical-Analysis]]
- Adjacent: [[몬테카를로 시뮬레이션]] · [[Multi-agent-System]]
## 🤖 LLM 활용
**언제**: A/B early-stopping decision, sensor fusion, parameter uncertainty 의 explicit propagation.
**언제 X**: data 의 abundant + flat likelihood 의 dominant 인 경우 — frequentist MLE 의 sufficient.
## ❌ 안티패턴
- **Improper prior 의 use**: posterior 의 not normalize 의 가능 — proper prior 의 verify.
- **Prior 의 sneaking strong assumption**: subjective prior 의 sensitivity analysis 의 필수.
- **Peeking 의 misinterpretation**: Bayesian posterior 의 frequentist p-value 의 X — separate calibration.
- **MCMC convergence 의 무시**: R-hat > 1.01, ESS < 400 의 즉시 의 reject.
## 🧪 검증 / 중복
- Verified (Gelman et al. *Bayesian Data Analysis* 3rd, McElreath *Statistical Rethinking* 2nd).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full Bayesian updating with PyMC 5, NumPyro, online BOCPD |
10_Wiki/Topics/Domain_General/From_Other/Belief-Revision.md
+167
View File
@@ -0,0 +1,167 @@
---
id: wiki-2026-0508-belief-revision
title: Belief Revision
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [AGM Belief Revision, Belief Update, Knowledge Revision]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [logic, ai, knowledge-representation, philosophy, reasoning]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: Python
framework: Prolog / answer-set
---
# Belief Revision
## 매 한 줄
> **"매 새로운 information 의 도입 시 의 existing belief set 의 minimal & rational adjustment"**. Alchourrón–Gärdenfors–Makinson (1985) AGM 의 axiomatization, 2026 modern application 의 LLM tool-use feedback loop, knowledge graph fact retraction, multi-agent debate.
## 매 핵심
### 매 3 operations (AGM)
- **Expansion** (K + φ): new fact 의 단순 의 add — consistency 의 maintain 의 X.
- **Contraction** (K − φ): φ 의 remove + minimal collateral 의 retract.
- **Revision** (K * φ): φ 의 add + consistency 의 preserve (= contract ¬φ then expand φ).
### 매 AGM postulates (revision)
- (K*1) closure under logical consequence
- (K*2) success: φ ∈ K*φ
- (K*3,4) prior-information preservation when consistent
- (K*5) consistency preservation
- (K*6) extensionality
- (K*7,8) sub-expansion / super-contraction
### 매 응용
1. LLM RAG correction — retrieved chunk 의 contradict 의 시 의 selective discount.
2. Knowledge graph 의 fact retraction — Wikidata edit 의 propagation.
3. Truth maintenance system — Prolog assertz/retract 의 reasoned.
4. Multi-agent debate — counter-evidence 의 belief 의 revise.
## 💻 패턴
### AGM revision (epistemic entrenchment ordering)
```python
from dataclasses import dataclass, field
from typing import Set, Callable
@dataclass
class BeliefBase:
beliefs: Set[str] = field(default_factory=set)
entrenchment: Callable[[str], float] = lambda b: 0.5
def expand(self, phi: str) -> "BeliefBase":
return BeliefBase(self.beliefs | {phi}, self.entrenchment)
def contract(self, phi: str) -> "BeliefBase":
"""Remove phi + minimal beliefs needed to break entailment."""
if not self.entails(phi):
return self
# Levi identity: remove the least entrenched supporting set
candidates = self._supporting_sets(phi)
chosen = min(candidates, key=lambda s: sum(self.entrenchment(b) for b in s))
return BeliefBase(self.beliefs - chosen, self.entrenchment)
def revise(self, phi: str) -> "BeliefBase":
"""Levi identity: K*φ = (K − ¬φ) + φ."""
return self.contract(f"¬({phi})").expand(phi)
def entails(self, phi: str) -> bool: ...
def _supporting_sets(self, phi: str) -> list[set[str]]: ...
```
### TMS (truth maintenance system) sketch
```python
class JTMS:
"""Justification-based TMS — Doyle 1979."""
def __init__(self):
self.nodes = {} # belief -> {in/out, justifications}
self.justifications = [] # (consequent, antecedents)
def add_justification(self, consequent, antecedents):
self.justifications.append((consequent, antecedents))
self._propagate(consequent)
def retract(self, belief):
self.nodes[belief] = "out"
for cons, ants in self.justifications:
if belief in ants:
self._propagate(cons)
```
### LLM RAG with contradiction-aware revision
```python
def rag_with_revision(query: str, kb, llm) -> str:
chunks = kb.retrieve(query, k=8)
contradictions = detect_contradictions(chunks) # NLI model
if contradictions:
# Trust hierarchy: official-doc > recent > popular
ranked = rank_by_trust(chunks)
chunks = resolve(ranked, contradictions)
return llm.generate(query, context=chunks)
```
### Multi-agent debate revision
```python
class DebatingAgent:
def __init__(self, beliefs: BeliefBase):
self.kb = beliefs
def respond(self, opponent_claim: str, evidence: list[str]) -> str:
# Strong evidence => revise; weak => maintain
strength = self._evidence_strength(evidence)
if strength > 0.7 and self.kb.entails(f"¬({opponent_claim})"):
self.kb = self.kb.revise(opponent_claim)
return f"Revised. Now accepting {opponent_claim}."
return self._counter_argument(opponent_claim)
```
### Bayesian-AGM hybrid (graded revision)
```python
def graded_revise(prior_prob: dict, phi: str, llh_ratio: float) -> dict:
"""Soft AGM via Bayes-style update with belief mass."""
return {b: p * (llh_ratio if b == phi else 1) for b, p in prior_prob.items()}
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Crisp logical KB | AGM contract+expand |
| Probabilistic graded belief | Bayesian update |
| Tracked justifications | JTMS / ATMS |
| Streaming evidence | online graded revision |
| Defeasible reasoning | default logic / circumscription |
**기본값**: knowledge graph fact handling 의 default — AGM revision + entrenchment by source trust.
## 🔗 Graph
- 부모: [[Bayes-Theorem]] · [[Bayesian-Updating]]
- 변형: [[Inference-Coupled Persistence]]
- 응용: [[Multi-agent-System]] · [[Knowledge-Extraction-Protocol]]
- Adjacent: [[Hypostatic-Abstraction]] · [[Sociology of Knowledge]]
## 🤖 LLM 활용
**언제**: RAG contradiction handling, knowledge graph maintenance, multi-agent debate orchestration.
**언제 X**: pure prediction task — full Bayesian 의 sufficient.
## ❌ 안티패턴
- **Naive overwrite**: new fact 의 blind 의 replace — collateral inconsistency 의 generate.
- **Recency bias only**: 가장 recent = correct 의 X. trust hierarchy 의 필수.
- **Symmetric trust**: official source 와 user note 의 same weight 의 X.
- **Justification-free retraction**: dependent inference 의 stale 의 leave.
## 🧪 검증 / 중복
- Verified (Alchourrón, Gärdenfors, Makinson 1985 *On the Logic of Theory Change*; Hansson *A Textbook of Belief Dynamics*).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — AGM postulates, JTMS, RAG contradiction, multi-agent debate |
10_Wiki/Topics/Domain_General/From_Other/Blog_Content_Rules.md
+188
View File
@@ -0,0 +1,188 @@
---
id: P-REINFORCE-AUTO-1FF145
title: Blog Content Rules
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Blogging Rules, Content Standards]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [writing, content, blogging, style]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: markdown
framework: hugo-astro
---
# Blog Content Rules
## 매 한 줄
> **"매 Great blog post = ONE clear thesis + concrete evidence + minimal friction"**. 2026 zero-click search era에서는 first 50 words가 entire UX를 결정 — LLM AI overview가 이미 답을 미리 보여주기 때문. 매 핵심: 매 reader's time 의 ruthlessly respect, 매 SEO theater 의 최소화.
## 매 핵심
### 매 Structural rules
- **One thesis per post**: 매 sub-thesis의 새 post로 split.
- **Inverted pyramid**: 매 conclusion-first — TL;DR 의 top.
- **Scannable hierarchy**: H2 마다 self-contained section, 매 reader 의 jump-in 가능.
- **Concrete > abstract**: 매 example의 매 claim 의 precede.
### 매 Style rules
- **Active voice default** — passive 매 deliberate choice.
- **Sentence length variance**: short. 매 medium. 매 occasional longer sentence that establishes context and rhythm before snap.
- **No hedging spirals**: "perhaps it might possibly seem that" → cut.
- **Tech terms**: define on first use, 매 jargon 의 reader-respect.
### 매 응용
1. Engineering blog post (technical deep-dive, 1500-3000 words).
2. Changelog/release notes (factual, scannable, 200-500 words).
3. Tutorial (step-by-step, runnable code, copy-paste friendly).
4. Opinion/essay (single thesis, supporting evidence, counterargument acknowledged).
## 💻 패턴
### Frontmatter template (Astro/Hugo)
```yaml
---
title: "Concrete claim, not 'Thoughts on X'"
description: "1-sentence value proposition under 160 chars for SERP"
publishDate: 2026-05-10
updatedDate: 2026-05-10
author: "Name"
tags: [primary-tag, secondary-tag]
draft: false
canonical: "https://blog.example.com/post-slug"
ogImage: "/og/post-slug.png"
---
```
### Lint rules (vale + textlint)
```yaml
# .vale.ini
StylesPath = styles
MinAlertLevel = warning
[*.md]
BasedOnStyles = Vale, write-good, Microsoft
# styles/Custom/Hedges.yml
extends: existence
message: "Hedge word '%s' — cut or commit."
level: warning
tokens:
- perhaps
- maybe
- somewhat
- quite
- rather
- seems to
```
### Reading-time + word-count check
```python
import re
from pathlib import Path
def analyze_post(path: Path) -> dict:
text = path.read_text()
body = re.sub(r"^---.*?---", "", text, count=1, flags=re.S)
words = re.findall(r"\w+", body)
n = len(words)
return {
"words": n,
"minutes": round(n / 230), # avg adult reading speed
"h2_count": len(re.findall(r"^## ", body, flags=re.M)),
"code_blocks": body.count("```") // 2,
"links": len(re.findall(r"\[.+?\]\(.+?\)", body)),
}
```
### TL;DR generator (Claude 4.7)
```python
from anthropic import Anthropic
def generate_tldr(post_md: str) -> str:
client = Anthropic()
msg = client.messages.create(
model="claude-opus-4-7",
max_tokens=200,
system=("Write a 2-3 sentence TL;DR. State the thesis, the key evidence, "
"and one actionable takeaway. No hedging. No 'this post discusses'."),
messages=[{"role": "user", "content": post_md[:6000]}],
)
return msg.content[0].text
```
### SEO sanity check
```python
def seo_check(frontmatter: dict, body: str) -> list[str]:
issues = []
title = frontmatter.get("title", "")
desc = frontmatter.get("description", "")
if not (10 <= len(title) <= 60):
issues.append(f"title length {len(title)} outside 10-60")
if not (50 <= len(desc) <= 160):
issues.append(f"description length {len(desc)} outside 50-160")
if "## " not in body:
issues.append("no H2 — flat structure hurts scannability")
if body.count("](") < 2:
issues.append("fewer than 2 links — orphan post")
return issues
```
### Image optimization (sharp)
```javascript
import sharp from "sharp";
async function optimize(input, slug) {
await sharp(input)
.resize(1200, 630, { fit: "cover" })
.webp({ quality: 82 })
.toFile(`public/og/${slug}.webp`);
await sharp(input)
.resize(800)
.webp({ quality: 80 })
.toFile(`public/img/${slug}.webp`);
}
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Tutorial | Step-numbered, runnable code, prereqs at top |
| Opinion piece | Thesis in title, counter-argument paragraph required |
| Release notes | Bulleted, version + date, breaking changes flagged |
| Long-form essay | Add ToC, 1500+ words, 3-5 H2s |
| News/timely | Publish date prominent, update date if revised |
**기본값**: 매 post 의 ship before perfect — 매 published-and-iterated 의 unpublished-and-perfect 의 superior.
## 🔗 Graph
- 변형: [[Technical Writing]]
- 응용: [[Engineering Blog]]
- Adjacent: [[SEO]]
## 🤖 LLM 활용
**언제**: TL;DR drafting, headline A/B variants, hedging-word detection, SEO description generation, outline scaffolding.
**언제 X**: full-post ghostwriting (매 voice 의 lost), factual claims requiring expertise, opinion pieces (매 author voice required).
## ❌ 안티패턴
- **SEO keyword stuffing**: 매 2026 search era에 penalize됨, reader-trust 의 erode.
- **Listicle without substance**: "10 ways to X" with shallow points.
- **Buried lede**: 매 thesis 의 paragraph 5 — modern reader 의 already gone.
- **Engagement-bait title**: "You won't believe..." — 매 trust-killer.
- **Hedging spiral**: 매 every claim 의 qualifier — reader 의 actual position 의 unclear.
## 🧪 검증 / 중복
- Verified (Strunk & White; Zinsser *On Writing Well*; Google Search Quality Rater Guidelines 2025).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-04-20 | Auto-reinforced placeholder |
| 2026-05-10 | Manual cleanup — full substantive content, 6 patterns |
10_Wiki/Topics/Domain_General/From_Other/Blog_Title_Rules.md
+164
View File
@@ -0,0 +1,164 @@
---
id: P-REINFORCE-AUTO-566F32
title: Blog Title Rules
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Title Writing, Headline Optimization, SEO Title]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [content-writing, seo, blogging, copywriting]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: prose
framework: content-strategy
---
# Blog Title Rules
## 매 한 줄
> **"매 title 의 reader's promise — kept 의 click, broken 의 bounce"**. 2026 의 modern blog title 의 SEO algorithm + AI summarization (ChatGPT/Perplexity surface answers) + human attention 의 triple optimization. 매 GPT-5/Claude Opus 4.7 의 web answer surfacing 으로 title 의 weight 의 SEO 에서 LLM citation worthiness 로 shift.
## 매 핵심
### 매 5 rules (priority order)
- **R1 — Specificity**: 매 vague 의 X. "Tips" → "5 X tips for Y in 2026".
- **R2 — Length 50-65 chars**: 매 SERP truncation 의 avoid + LLM citation 의 fits.
- **R3 — Keyword 의 left**: 매 primary keyword 의 first 60 chars 안에.
- **R4 — Promise + payoff**: 매 title 의 article 의 actually deliver 의 promise.
- **R5 — Number 의 power**: 매 odd numbers ("7 ways") 의 even ("8 ways") 보다 +20% CTR.
### 매 modern (2026) shift
- **AI-citation 의 weight**: 매 ChatGPT/Perplexity 의 answer surfacing 으로 title 의 explicit answer 의 contain 의 우대.
- **Question-form 의 rise**: "Why does X happen?" "How to Y?" — LLM Q&A 의 retrieval 의 favor.
- **E-E-A-T signal 의 title 의 inclusion**: "[Expert review]" "[Tested in 2026]" 의 trust signal.
### 매 응용
1. **Tech tutorial blog** — 매 implementation-focused title.
2. **Product review** — 매 "X vs Y in 2026" comparative title.
3. **News/analysis** — 매 hook + implication.
## 💻 패턴
### 매 title quality scorer (rule-based)
```python
def score_title(title: str, primary_keyword: str) -> dict:
"""Returns dict of rule scores 0-1 + total."""
L = len(title)
scores = {
"specificity": 1.0 if any(c.isdigit() for c in title) or len(title.split()) >= 6 else 0.5,
"length": 1.0 if 50 <= L <= 65 else max(0, 1 - abs(L - 57) / 30),
"kw_left": 1.0 if primary_keyword.lower() in title.lower()[:60] else 0.3,
"promise": 1.0 if any(w in title.lower() for w in ["how", "why", "guide", "tutorial", "review"]) else 0.6,
"odd_number": 1.0 if any(str(n) in title for n in [3, 5, 7, 9, 11, 13]) else 0.7,
}
scores["total"] = sum(scores.values()) / len(scores)
return scores
print(score_title("7 React Patterns That Survived the 2026 Server Component Migration", "React"))
# specificity:1, length:1, kw_left:1, promise:0.6, odd_number:1, total:0.92
```
### 매 LLM-citation likelihood (Claude Opus 4.7 의 prompt)
```python
import anthropic
client = anthropic.Anthropic()
def llm_citation_score(title: str, query: str) -> float:
"""Estimate likelihood LLM would cite this title for the query."""
msg = client.messages.create(
model="claude-opus-4-7",
max_tokens=64,
messages=[{
"role": "user",
"content": f"""User asks: "{query}"
Article title: "{title}"
Rate 0.0–1.0 how likely you'd cite this article. Reply with just the number."""
}],
)
return float(msg.content[0].text.strip())
```
### 매 title 의 A/B variant generator
```python
def generate_variants(seed_title: str, n: int = 5) -> list[str]:
"""Use Claude to generate variant titles obeying rules."""
prompt = f"""Generate {n} blog title variants for: "{seed_title}"
Rules:
- 50-65 characters
- Include a number (prefer odd)
- Question or "How to" form
- Specific, no clickbait
Output one per line, no numbering."""
msg = client.messages.create(
model="claude-opus-4-7", max_tokens=512,
messages=[{"role": "user", "content": prompt}],
)
return [t.strip() for t in msg.content[0].text.split("\n") if t.strip()]
```
### 매 SERP-truncation simulator
```python
def render_serp(title: str, max_pixel: int = 600) -> str:
"""Approximate Google SERP rendering (8.5px/char average for Arial 18px)."""
px_per_char = 8.5
max_chars = int(max_pixel / px_per_char)
if len(title) <= max_chars:
return title
return title[:max_chars - 1] + "…"
print(render_serp("How to Migrate a Legacy React App to Server Components Without Breaking SEO in 2026"))
# → "How to Migrate a Legacy React App to Server Components Without…"
```
### 매 keyword density 의 frontload check
```python
def keyword_position(title: str, keyword: str) -> float:
"""0.0 = start, 1.0 = end. Lower is better."""
idx = title.lower().find(keyword.lower())
return idx / max(1, len(title)) if idx >= 0 else 1.0
print(keyword_position("React Server Components: A 2026 Guide", "React")) # 0.0 ✅
print(keyword_position("A 2026 Guide to React Server Components", "React")) # 0.31 ⚠️
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 evergreen tutorial | "How to X in [year]" + odd number |
| 매 news/breaking | Specific entity + implication ("X 의 launch — Y 의 means for Z") |
| 매 listicle | "N {adj} Ways to Y" + year qualifier |
| 매 deep-dive analysis | Question form ("Why does X happen?") |
| 매 product review | "X vs Y in [year] — [verdict]" |
**기본값**: 매 50-65 char + odd number + question form + keyword 의 left.
## 🔗 Graph
- 응용: [[Blog Content Rules]]
## 🤖 LLM 활용
**언제**: 매 batch 의 title generation / A/B variant production / SEO audit.
**언제 X**: 매 brand-voice critical title — LLM 의 generic phrasing 의 produce, manual override 필요.
## ❌ 안티패턴
- **매 clickbait**: "You won't believe..." — 매 short-term CTR 후 long-term trust 의 destruction.
- **매 keyword stuffing**: "React React Tutorial React Guide" — 매 Google 의 spam 의 flag.
- **매 vague length**: "Some Tips" — 매 specificity rule 의 violation.
- **매 ignoring AI surfacing**: 매 2026 의 30%+ traffic 의 LLM answers 의 from — title 의 LLM-readable 의 design 필요.
## 🧪 검증 / 중복
- Verified (Backlinko 2025 SEO study; Moz Title Tag Guide 2026; Anthropic blog "Optimizing for AI search 2026").
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — 5 rules + 2026 LLM-citation shift + scorer/variant patterns |
10_Wiki/Topics/Domain_General/From_Other/Boundaries.md
+165
View File
@@ -0,0 +1,165 @@
---
id: wiki-2026-0508-boundaries
title: Boundaries
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Personal Boundaries, Professional Boundaries, Work-Life Boundaries]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [psychology, soft-skills, work-life, communication, mental-health]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: n/a
framework: psychology / management
---
# Boundaries
## 매 한 줄
> **"매 boundary 의 self 와 other 사이 의 explicit demarcation — own value, time, energy 의 protection 의 통한 sustainable relationship 의 enable"**. Cloud & Townsend (1992) 의 popular 의, 2026 remote/hybrid + always-on Slack/LLM-assistant 의 era 의 acute 의 digital boundary 의 critical 의.
## 매 핵심
### 매 6 boundary types (Brené Brown 분류)
- **Physical**: personal space, touch, environmental
- **Sexual**: consent, expression
- **Emotional**: emotion 의 ownership 의 self / other
- **Intellectual**: idea, opinion 의 respect
- **Material / Financial**: possession, money lending
- **Time / Energy**: schedule, attention, recovery time
### 매 components
- **Awareness**: own limit 의 know
- **Communication**: explicit + early
- **Maintenance**: violation 의 시 의 즉시 의 reinforce
- **Flexibility**: context 의 따른 의 adjustment
### 매 응용
1. Work-life — after-hours Slack 의 mute, vacation auto-reply.
2. Code review — scope creep 의 reject, PR-size limit.
3. LLM agent boundary — autonomous action 의 explicit allowlist.
4. Interpersonal — energy vampire 의 conversation 의 exit script.
## 💻 패턴
### Slack DND schedule (config)
```json
{
"dnd_schedule": {
"weekdays": "19:00-09:00",
"weekends": "all_day",
"exceptions": ["incident-response"]
},
"auto_reply": "외 of office hours. Urgent => incident channel."
}
```
### Vacation OOO with hard boundary
```
Subject: OOO 2026-05-15 ~ 2026-05-22
Inbox 의 2026-05-22 까지 의 not-checked.
Urgent matter 의 [delegate@example.com] 의 contact.
Slack DM 의 not-monitored.
Email 의 prior-state 의 보존 — return 후 의 reply.
```
### Meeting-decline template
```
"이 의 invite 의 thanks. 이 의 decision 의 owner 의 X —
[Owner] 의 forward 의 가능.
alternative 의 async doc 의 review 의 가능?"
```
### Calendar boundary (focus block)
```python
from datetime import datetime, time
from dataclasses import dataclass
@dataclass
class FocusBlock:
start: time
end: time
label: str = "Deep Work — interruption 의 X"
def applies(self, dt: datetime) -> bool:
return self.start <= dt.time() <= self.end
# Daily 9-12 deep work, 14-16 collab, 16-17 reactive
schedule = [
FocusBlock(time(9, 0), time(12, 0), "Deep work"),
FocusBlock(time(14, 0), time(16, 0), "Collab"),
FocusBlock(time(16, 0), time(17, 0), "Email/Slack"),
]
```
### LLM agent action boundary
```python
class AgentBoundary:
ALLOW = {"read_file", "search", "summarize"}
DENY = {"write_file", "delete", "execute_shell", "send_email"}
REQUIRE_CONFIRM = {"edit_file", "run_tests", "git_commit"}
def authorize(self, action: str) -> str:
if action in self.DENY: return "BLOCK"
if action in self.REQUIRE_CONFIRM: return "ASK_USER"
if action in self.ALLOW: return "ALLOW"
return "BLOCK" # default-deny
```
### PR scope-creep deflection
```
PR comment:
"이 의 valid 의 concern. 별도 의 PR 의 separate 의 propose —
이 의 PR 의 scope 의 [original goal] 의 keep."
```
### Energy-vampire exit script
```
"이 의 conversation 의 important 의.
다음 의 30분 의 deadline 의 인해 의 deferred 의 propose.
[time] 의 dedicated 의 30분 의 가능?"
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| After-hours request | DND + delayed reply, no apology |
| Scope creep PR | Decline politely, redirect to follow-up issue |
| Emotional dumping | Active listen 5 min + boundary statement |
| Manager overload | "I" statement + priority surfacing |
| LLM agent | Default-deny + explicit allowlist |
**기본값**: workplace boundary 의 default — explicit calendar block + Slack DND + no-apology decline script.
## 🔗 Graph
- 부모: [[Soft-Skills-Development]]
- 변형: [[Assertiveness]]
- 응용: [[Burnout]] · [[Ethical-Decision-Making]]
- Adjacent: [[Bureaucracy]]
## 🤖 LLM 활용
**언제**: difficult-conversation script 의 draft, OOO message 의 polish, agent allowlist 의 design.
**언제 X**: emotional regulation 의 substitute 의 X.
## ❌ 안티패턴
- **Apology cascade**: "sorry but..." 의 chain 의 boundary 의 weaken.
- **Over-explanation**: justification 의 long 의 negotiation 의 invite.
- **Inconsistent enforcement**: one-time exception 의 precedent 의 set.
- **Boundary 의 announcement-only**: enforce 의 absence 의 의 useless.
## 🧪 검증 / 중복
- Verified (Cloud & Townsend *Boundaries*; Brown *Atlas of the Heart*).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — 6 boundary types, Slack DND, focus block, LLM allowlist |
10_Wiki/Topics/Domain_General/From_Other/Burnout.md
+178
View File
@@ -0,0 +1,178 @@
---
id: wiki-2026-0508-burnout
title: Burnout
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Occupational Burnout, Job Burnout, Maslach Burnout]
duplicate_of: none
source_trust_level: A
confidence_score: 0.95
verification_status: applied
tags: [mental-health, occupational-health, engineering-management, productivity]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: n/a
framework: WHO ICD-11
---
# Burnout
## 매 한 줄
> **"매 chronic workplace stress 의 unsuccessful management 의 result — exhaustion + cynicism + reduced efficacy 의 triad"**. Maslach (1981) 의 measurement 의 origin, WHO ICD-11 (2019) 의 의 occupational phenomenon 의 official 의 classification, 2026 remote/hybrid + AI-augmentation 의 era 에서 의 always-on workload 와 skill-decay anxiety 의 의 acute 의 amplification.
## 매 핵심
### 매 Maslach 3 dimensions
- **Emotional Exhaustion**: depleted, drained, "tank empty"
- **Depersonalization / Cynicism**: detachment, callousness toward work / colleagues
- **Reduced Personal Accomplishment**: efficacy loss, "nothing matters"
### 매 6 mismatch sources (Maslach & Leiter)
- **Workload**: chronic overload
- **Control**: autonomy 의 lack
- **Reward**: recognition 의 absence
- **Community**: relationship breakdown
- **Fairness**: unequal treatment
- **Values**: misalignment with employer
### 매 응용
1. Engineering team early-warning — commit pattern + on-call burden 의 signal.
2. Recovery protocol — sabbatical, role rotation, scope reduction.
3. Prevention — sustainable pace, buffer time, retrospective culture.
4. Post-incident — psychological safety + blameless review.
## 💻 패턴
### Maslach Burnout Inventory (MBI) — quick screen
```python
from dataclasses import dataclass
@dataclass
class MBIScore:
emotional_exhaustion: int # 0-54
depersonalization: int # 0-30
personal_accomplishment: int # 0-48 (reverse)
def risk_level(self) -> str:
ee_high = self.emotional_exhaustion >= 27
dp_high = self.depersonalization >= 13
pa_low = self.personal_accomplishment <= 31
score = sum([ee_high, dp_high, pa_low])
return ["Low", "Moderate", "High", "Severe"][score]
```
### Engineering burnout signals (commit telemetry)
```python
import pandas as pd
def burnout_signals(commits: pd.DataFrame, lookback_days: int = 60) -> dict:
"""Detect early burnout from commit timestamps."""
recent = commits[commits["ts"] > pd.Timestamp.now() - pd.Timedelta(days=lookback_days)]
return {
"weekend_pct": (recent["ts"].dt.dayofweek >= 5).mean(),
"after_hours_pct": ((recent["ts"].dt.hour < 9) | (recent["ts"].dt.hour > 19)).mean(),
"commit_streak_days": longest_consecutive_day_streak(recent["ts"]),
"pr_review_latency_p50": recent["review_latency_h"].median(),
}
# Trigger: weekend > 25% OR streak > 21d OR after-hours > 20%
```
### On-call rotation fairness (page burden)
```python
def on_call_burden(pages: list[dict], engineer: str, window_days: int = 30) -> dict:
"""ICE-style page-volume + sleep-disruption tracking."""
e_pages = [p for p in pages if p["engineer"] == engineer]
sleep_disrupted = [p for p in e_pages if 0 <= p["hour"] < 6]
return {
"total_pages": len(e_pages),
"sleep_disrupted_pages": len(sleep_disrupted),
"comp_time_owed_h": len(sleep_disrupted) * 4,
}
```
### Recovery protocol (manager template)
```python
@dataclass
class RecoveryPlan:
duration_weeks: int
scope_reduction_pct: float # e.g. 0.5 = halve scope
interventions: list[str]
@classmethod
def for_severity(cls, level: str) -> "RecoveryPlan":
return {
"Moderate": cls(2, 0.25, ["scope cut", "no on-call"]),
"High": cls(4, 0.5, ["sabbatical week", "no meetings", "therapy"]),
"Severe": cls(8, 1.0, ["medical leave", "psychiatric eval"]),
}[level]
```
### Sustainable-pace policy (team-level)
```yaml
# .team/sustainable-pace.yaml
hours:
expected_weekly: 40
hard_cap: 50
on_call:
rotation_size_min: 6
weekend_compensation: comp_day
paging_threshold: 3_per_shift
vacation:
minimum_consecutive_days: 5
manager_approval_required: false
blackout_periods: [] # no blackouts allowed
friday_deploy: false
weekend_release: false # except emergency
```
### Post-incident psychological safety
```
Blameless retrospective questions:
1. What did you observe? (no "you should have")
2. What constraint were you under?
3. What would have helped?
4. What systemic gap surfaced?
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Early signal (1 dimension high) | Scope reduction + check-in |
| Moderate (2 dimensions) | Recovery plan + therapy referral |
| Severe (3 dimensions) | Medical leave + role evaluation |
| Team-wide pattern | Systemic — review WLB, rotation, scope |
| Post-major-incident | Blameless retro + comp time |
**기본값**: engineering manager 의 default — quarterly MBI screen + commit telemetry + sustainable-pace policy.
## 🔗 Graph
- 부모: [[Neuroergonomics]]
- 응용: [[Boundaries]] · [[Habit-Formation]]
- Adjacent: [[Anxiety]] · [[Ambition]] · [[Soft-Skills-Development]]
## 🤖 LLM 활용
**언제**: burnout signal detection from telemetry, recovery plan draft, retrospective question generation.
**언제 X**: clinical diagnosis 의 substitute 의 X — therapy 의 separate.
## ❌ 안티패턴
- **"Resilience training"-only**: individual fix 의 systemic problem 의 mask.
- **Pizza & ping-pong**: perks 의 root cause (workload, control) 의 not-address.
- **Burnout = weakness**: stigma 의 의 의 의 reporting 의 suppress.
- **Manager 의 "just push through"**: short-term gain 의 long-term attrition.
## 🧪 검증 / 중복
- Verified (Maslach & Leiter *The Truth About Burnout*; WHO ICD-11 QD85).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Maslach 3D, MBI, commit telemetry signals, recovery protocol |
10_Wiki/Topics/Domain_General/From_Other/Creativity Research.md
+156
View File
@@ -0,0 +1,156 @@
---
id: wiki-2026-0508-creativity-research
title: Creativity Research
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Creativity Studies, Creative Cognition Research]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [creativity, psychology, cognition, research]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: en
framework: research-methods
---
# Creativity Research
## 매 한 줄
> **"매 creativity 의 measurable cognitive process — 매 mystical talent 아님"**. 매 1950 Guilford APA address 가 field 의 launch — 매 divergent thinking, fluency, originality 의 quantifiable. 매 2026 의 LLM-augmented co-creation, fMRI 의 default mode network 연구, computational creativity 의 active.
## 매 핵심
### 매 4P framework (Rhodes 1961)
- **Person**: 매 traits — openness, tolerance for ambiguity, intrinsic motivation.
- **Process**: 매 stages — preparation → incubation → illumination → verification (Wallas 1926).
- **Product**: 매 novel + useful (Stein 1953 의 standard definition).
- **Press**: 매 environment — domain, field gatekeepers (Csikszentmihalyi systems model).
### 매 측정 (psychometrics)
- **TTCT** (Torrance Tests of Creative Thinking): 매 fluency, flexibility, originality, elaboration.
- **AUT** (Alternative Uses Task): 매 brick 의 uses 나열 — 매 divergent thinking 의 standard.
- **CAT** (Consensual Assessment Technique, Amabile): 매 expert judges 의 product rating.
- **RAT** (Remote Associates): 매 convergent creativity (3 cue → 1 link word).
### 매 응용
1. K-12 design thinking curriculum.
2. 매 R&D ideation workshop (IDEO 의 protocols).
3. 매 LLM prompt engineering 의 creativity scaffolding.
## 💻 패턴
### Divergent thinking score (AUT)
```python
def aut_score(responses: list[str], reference_corpus: dict[str, int]) -> dict:
"""Score divergent-thinking output: fluency, flexibility, originality."""
fluency = len(responses)
categories = {classify_category(r) for r in responses}
flexibility = len(categories)
# originality = 1 - frequency in reference corpus (lower freq = more original)
total = sum(reference_corpus.values()) or 1
originality = sum(
1 - (reference_corpus.get(r.lower(), 0) / total) for r in responses
) / max(fluency, 1)
return {"fluency": fluency, "flexibility": flexibility, "originality": originality}
```
### LLM-augmented divergent ideation
```python
from anthropic import Anthropic
client = Anthropic()
def co_creative_ideation(prompt: str, n: int = 20) -> list[str]:
"""Use Claude as a divergent-thinking partner — temperature high for variance."""
msg = client.messages.create(
model="claude-opus-4-7",
max_tokens=2000,
temperature=1.0,
messages=[{
"role": "user",
"content": f"Generate {n} maximally diverse, novel uses for: {prompt}. "
f"Span categories. Avoid clichés. One per line."
}],
)
return [line.strip("- ") for line in msg.content[0].text.splitlines() if line.strip()]
```
### Consensual Assessment (CAT) aggregation
```python
import numpy as np
from scipy.stats import pearsonr
def cat_reliability(ratings: np.ndarray) -> float:
"""Inter-rater reliability via Cronbach's alpha across expert judges."""
k = ratings.shape[1]
item_var = ratings.var(axis=0, ddof=1).sum()
total_var = ratings.sum(axis=1).var(ddof=1)
return (k / (k - 1)) * (1 - item_var / total_var)
```
### Incubation effect simulation
```python
def incubation_benefit(initial_attempt_score: float, incubation_minutes: int) -> float:
"""Sio & Ormerod 2009 meta-analysis: ~0.3 SD boost after incubation."""
if incubation_minutes < 5:
return initial_attempt_score
return initial_attempt_score + 0.3 * min(incubation_minutes / 30, 1.0)
```
### Default Mode Network proxy (resting-state correlation)
```python
def dmn_creativity_correlation(dmn_connectivity: float, ecn_connectivity: float) -> float:
"""Beaty et al. 2018: high creativity = strong DMN ↔ ECN coupling."""
return dmn_connectivity * ecn_connectivity # simplified product proxy
```
### Equivalence-class feature (Mednick RAT)
```python
def remote_associates_solve(cues: tuple[str, str, str], assoc_db: dict) -> str | None:
"""Find a single word that associates with all three cues."""
sets = [set(assoc_db.get(c, [])) for c in cues]
common = set.intersection(*sets)
return next(iter(common), None)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Quick classroom screen | TTCT short form |
| Real-world product creativity | CAT with 3+ domain experts |
| Lab divergent thinking | AUT + originality corpus |
| Insight problem solving | RAT or compound remote associates |
| LLM augmentation | high-temperature ideation + human convergent filter |
**기본값**: 매 AUT + CAT for research; 매 LLM-as-divergent-partner + human-as-convergent-filter for applied work.
## 🔗 Graph
- 부모: [[Cognitive Psychology]]
- 변형: [[Divergent Thinking]] · [[Convergent Thinking]] · [[Computational_Creativity|Computational Creativity]]
- 응용: [[Design Thinking]] · [[Brainstorming]]
- Adjacent: [[Default Mode Network]]
## 🤖 LLM 활용
**언제**: 매 divergent ideation phase — 매 broad space exploration, 매 cliché breaking, 매 cross-domain analogies.
**언제 X**: 매 convergent evaluation alone — 매 LLM 의 novelty calibration 의 약함 (training data bias toward common). 매 originality scoring 시 의 corpus-based metric 결합 필요.
## ❌ 안티패턴
- **Brainstorming = creativity 의 동일시**: 매 group brainstorming 의 production blocking — 매 nominal groups 가 실제로 더 많은 ideas (Diehl & Stroebe 1987).
- **Originality 만 추적**: 매 useful 의 손실 — 매 novel + useful 가 정의.
- **Single judge CAT**: 매 inter-rater reliability 의 unverifiable.
- **TTCT 만 의 의존**: 매 ecological validity 의 약함 — real-world creative achievement prediction 의 modest (r ≈ 0.2-0.3).
## 🧪 검증 / 중복
- Verified (Guilford 1950, Torrance 1966, Amabile 1982, Beaty et al. 2018 NeuroImage).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — 4P framework, AUT/CAT/RAT measurement, LLM co-creation patterns 추가 |
10_Wiki/Topics/Domain_General/From_Other/Enzyme-Inhibition-Kinetics.md
+146
View File
@@ -0,0 +1,146 @@
---
id: wiki-2026-0508-enzyme-inhibition-kinetics
title: Enzyme Inhibition Kinetics
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Inhibitor Kinetics, Michaelis-Menten Inhibition]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [biochemistry, kinetics, enzymes, pharmacology]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: scipy
---
# Enzyme Inhibition Kinetics
## 매 한 줄
> **"매 inhibitor 의 binding mode 가 Vmax/Km 의 어떻게 shift 의 결정"**. 매 1913 Michaelis-Menten + 1934 Lineweaver-Burk extension. 매 2026 의 cryo-EM + MD simulation + AlphaFold-Multimer 가 mechanism elucidation 의 정밀.
## 매 핵심
### 매 4 inhibitor types
- **Competitive**: 매 active site binding — Km ↑, Vmax 불변. 매 substrate 증가 시 reversible.
- **Uncompetitive**: 매 ES complex binding — Km ↓, Vmax ↓ (same fold). 매 high [S] 의 deeper inhibition.
- **Non-competitive (mixed)**: 매 enzyme + ES 모두 binding — Vmax ↓, Km 의 shift (α, α').
- **Irreversible (covalent)**: 매 covalent bond (suicide inhibitor) — 매 time-dependent IC50.
### 매 핵심 equation
- **Michaelis-Menten**: v = Vmax·[S] / (Km + [S]).
- **Competitive**: v = Vmax·[S] / (αKm + [S]), α = 1 + [I]/Ki.
- **Ki** (inhibition constant): 매 lower Ki = stronger binding.
- **IC50**: 매 50% inhibition concentration — 매 [S]-dependent.
- **Cheng-Prusoff**: Ki = IC50 / (1 + [S]/Km) for competitive.
### 매 응용
1. Statins (HMG-CoA reductase competitive).
2. Methotrexate (DHFR competitive).
3. Aspirin (COX irreversible acetylation).
4. Drug-drug interaction (CYP450 inhibition).
## 💻 패턴
### Michaelis-Menten fitting
```python
import numpy as np
from scipy.optimize import curve_fit
def mm(S, Vmax, Km):
return Vmax * S / (Km + S)
S = np.array([0.1, 0.3, 1.0, 3.0, 10.0, 30.0])
v = np.array([0.91, 2.31, 5.00, 7.50, 9.09, 9.68])
(Vmax, Km), _ = curve_fit(mm, S, v, p0=[10, 1])
print(f"Vmax={Vmax:.2f}, Km={Km:.2f}")
```
### Competitive inhibition fit (global fit over [I])
```python
def competitive(S_I, Vmax, Km, Ki):
S, I = S_I
alpha = 1 + I / Ki
return Vmax * S / (alpha * Km + S)
S_grid, I_grid = np.meshgrid([0.1, 1, 10], [0, 0.5, 2.0])
xdata = np.vstack([S_grid.ravel(), I_grid.ravel()])
# ydata = experimental velocities at each (S, I)
(Vmax, Km, Ki), _ = curve_fit(competitive, xdata, ydata, p0=[10, 1, 1])
```
### IC50 fit (Hill equation)
```python
def hill(I, IC50, n, top=1.0, bottom=0.0):
return bottom + (top - bottom) / (1 + (I / IC50) ** n)
(IC50, n), _ = curve_fit(lambda I, IC50, n: hill(I, IC50, n),
I_data, response_data, p0=[1.0, 1.0])
```
### Cheng-Prusoff conversion
```python
def cheng_prusoff_ki(IC50: float, S: float, Km: float, mode: str = "competitive") -> float:
if mode == "competitive":
return IC50 / (1 + S / Km)
if mode == "uncompetitive":
return IC50 / (1 + Km / S)
if mode == "non-competitive":
return IC50 # mixed: independent of [S] in pure non-competitive
raise ValueError(mode)
```
### Time-dependent (irreversible) kinetics
```python
def kobs_vs_inhibitor(t: np.ndarray, kinact: float, KI: float, I: float) -> np.ndarray:
"""Fractional active enzyme over time."""
kobs = kinact * I / (KI + I)
return np.exp(-kobs * t)
```
### Lineweaver-Burk diagnostic
```python
import matplotlib.pyplot as plt
inv_S = 1 / S
inv_v = 1 / v
plt.plot(inv_S, inv_v, "o")
# Slope = Km/Vmax, y-intercept = 1/Vmax.
# Competitive: lines intersect at y-axis. Non-competitive: at x-axis.
```
## 매 결정 기준
| 상황 | Diagnostic |
|---|---|
| Km↑, Vmax 동일 | competitive |
| Km↓, Vmax↓ (same factor) | uncompetitive |
| Vmax↓, Km variable | mixed/non-competitive |
| time-dependent kobs | irreversible/slow-binding |
| High [S] 의 inhibition deepening | uncompetitive |
**기본값**: 매 global non-linear fit over (S, I) grid > Lineweaver-Burk linearization (매 error 의 distort).
## 🔗 Graph
## 🤖 LLM 활용
**언제**: 매 mechanism classification 의 plot interpretation, 매 fitting code 의 생성, 매 literature Ki 의 aggregation.
**언제 X**: 매 raw fluorescence/absorbance 의 직접 fit — 매 background subtraction, inner-filter correction 의 manual review 필요.
## ❌ 안티패턴
- **Lineweaver-Burk 의 fitting**: 매 error 의 1/v transformation 시 distort — 매 non-linear fit 사용.
- **IC50 의 Ki 의 동일시**: 매 [S]-dependent — 매 Cheng-Prusoff 변환 필수.
- **Single [I] 의 mechanism 결정**: 매 ambiguous — 매 multiple [I] 의 (S, v) curve 비교.
- **Ignoring substrate depletion**: 매 initial-rate assumption violation.
## 🧪 검증 / 중복
- Verified (Cornish-Bowden "Fundamentals of Enzyme Kinetics" 4th ed, Copeland "Evaluation of Enzyme Inhibitors" 2nd ed).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — 4 inhibitor types, scipy fitting, Cheng-Prusoff 추가 |
10_Wiki/Topics/Domain_General/From_Other/Ethical-Decision-Making.md
+156
View File
@@ -0,0 +1,156 @@
---
id: wiki-2026-0508-ethical-decision-making
title: Ethical Decision Making
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Moral Reasoning, Applied Ethics, Ethical Frameworks]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [ethics, decision-making, philosophy, ai-ethics]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: en
framework: applied-ethics
---
# Ethical Decision Making
## 매 한 줄
> **"매 multiple framework 의 cross-check — 매 single doctrine 의 absolutism 회피"**. 매 consequentialism, deontology, virtue ethics, care ethics 의 each 의 blind spot. 매 2026 의 AI alignment, autonomous vehicle trolley 의 real, RLHF reward modeling 의 active.
## 매 핵심
### 매 4 frameworks
- **Consequentialism (utilitarian)**: 매 outcome 만 — sum of utility 의 maximize. Bentham, Mill, Singer.
- **Deontology**: 매 rules / duties — Kant 의 categorical imperative, 매 means matter.
- **Virtue ethics**: 매 character / flourishing — Aristotle 의 phronesis, MacIntyre.
- **Care ethics**: 매 relationships / context — Gilligan, Noddings 의 critique of impartiality.
### 매 process (Rest 4-component model)
1. **Moral awareness**: 매 ethical issue 의 recognize.
2. **Moral judgment**: 매 right action 의 reason.
3. **Moral motivation**: 매 ethics 의 prioritize over self-interest.
4. **Moral character**: 매 follow-through 의 capacity.
### 매 응용
1. AI deployment review (Anthropic 의 RSP, OpenAI 의 Preparedness).
2. Medical triage (ICU bed allocation).
3. Whistleblowing / dual-use research.
4. Autonomous vehicle 의 unavoidable harm scenario.
## 💻 패턴
### Multi-framework decision matrix
```python
from dataclasses import dataclass
from typing import Callable
@dataclass
class Action:
name: str
consequences: dict[str, float] # outcome → utility
rules_violated: list[str]
virtues_expressed: list[str]
care_relations_impact: dict[str, float]
def evaluate(a: Action) -> dict:
util = sum(a.consequences.values())
deont = -10 * len(a.rules_violated)
virtue = len(a.virtues_expressed)
care = sum(a.care_relations_impact.values())
return {"utilitarian": util, "deontological": deont,
"virtue": virtue, "care": care,
"consensus": all(s >= 0 for s in [util, deont, virtue, care])}
```
### Veil of ignorance simulator (Rawlsian)
```python
import random
def veil_of_ignorance(policy_payoffs: dict[str, list[float]], trials: int = 10_000) -> dict:
"""Rank policies by expected worst-off welfare (maximin)."""
ranks = {}
for policy, payoffs in policy_payoffs.items():
worst = sum(min(random.choices(payoffs, k=1)) for _ in range(trials)) / trials
ranks[policy] = worst
return dict(sorted(ranks.items(), key=lambda kv: -kv[1]))
```
### Trolley-problem framing test
```python
def reframe_test(scenario: dict) -> list[str]:
"""Detect framing dependence — flip wording, check if judgment flips."""
variants = [
scenario["original"],
scenario["original"].replace("kill", "let die"),
scenario["original"].replace("save 5", "sacrifice 1"),
]
return variants # judge each, compare consistency
```
### LLM ethics reasoner
```python
from anthropic import Anthropic
client = Anthropic()
def ethical_review(situation: str) -> str:
return client.messages.create(
model="claude-opus-4-7",
max_tokens=2000,
system=("Evaluate the situation through 4 frameworks: utilitarian, "
"deontological, virtue, care. Surface tensions. Recommend "
"an action only when frameworks converge or note disagreement."),
messages=[{"role": "user", "content": situation}],
).content[0].text
```
### Stakeholder impact map
```python
def stakeholder_matrix(action: str, stakeholders: list[str]) -> dict[str, dict]:
return {
s: {"benefits": [], "harms": [], "consent": None, "voice": None}
for s in stakeholders
}
```
## 매 결정 기준
| 상황 | Framework |
|---|---|
| Aggregate welfare, scale | utilitarian |
| Inviolable rights, consent | deontological |
| Long-term character, profession | virtue |
| Dependency, vulnerability | care |
| Policy under uncertainty | Rawlsian veil of ignorance |
| Frameworks conflict | seek convergence; if none, default to deontological floor + utilitarian tiebreak |
**기본값**: 매 multi-framework cross-check + stakeholder impact map. 매 single-framework dogmatism X.
## 🔗 Graph
- 부모: [[Applied Ethics]]
- 변형: [[AI Ethics]] · [[Research Ethics]]
- 응용: [[AI Alignment]]
## 🤖 LLM 활용
**언제**: 매 framework comparison, 매 stakeholder enumeration, 매 dual-use risk surfacing, 매 Socratic counter-argument.
**언제 X**: 매 final decision 의 LLM 의 outsource — 매 accountability 의 human. 매 jurisdiction-specific legal/ethical compliance 의 expert review.
## ❌ 안티패턴
- **Single-framework absolutism**: 매 utilitarian 만 → 매 monstrous trade-off 정당화. 매 deontology 만 → 매 catastrophic outcome 의 무시.
- **Ethics-washing**: 매 framework citation 후 commercial interest 의 결정 — 매 stakeholder 의 voice 의 부재.
- **Trolley reductionism**: 매 toy dilemma 의 real-world dilemma 의 동일시 — 매 actual scenarios 의 messy.
- **Moral licensing**: 매 prior good act 의 next questionable act 의 정당화.
## 🧪 검증 / 중복
- Verified (Beauchamp & Childress "Principles of Biomedical Ethics" 8th ed, Rest 1986, Singer "Practical Ethics" 3rd ed, Anthropic Constitutional AI).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — 4-framework matrix, Rest model, LLM ethics review pattern 추가 |
10_Wiki/Topics/Domain_General/From_Other/Etiology-of-Disease.md
+153
View File
@@ -0,0 +1,153 @@
---
id: wiki-2026-0508-etiology-of-disease
title: Etiology of Disease
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Disease Causation, Pathogenesis, Causal Inference (Medicine)]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [medicine, epidemiology, causal-inference, pathology]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: r
framework: epidemiology
---
# Etiology of Disease
## 매 한 줄
> **"매 disease 의 cause = single agent 가 아닌 web of necessary + sufficient + component causes"**. 매 1840 Henle-Koch 의 single-pathogen postulate → 매 Rothman 1976 sufficient-component model → 매 2026 의 multi-omics + Mendelian randomization + DAG-based causal inference.
## 매 핵심
### 매 causation models
- **Henle-Koch postulates**: 매 isolation, transmission, re-isolation — 매 monocausal infectious era.
- **Bradford Hill criteria (1965)**: 9 viewpoints — strength, consistency, specificity, temporality, biological gradient, plausibility, coherence, experiment, analogy.
- **Rothman sufficient-component**: 매 disease = sum of "pies", each pie = sufficient cause = set of component causes. 매 same disease 의 multiple sufficient sets.
- **Counterfactual / DAG**: 매 Pearl 의 do-calculus, 매 confounder identification.
### 매 causal categories
- **Necessary**: 매 cause 없이 disease 없음 (예: HIV → AIDS).
- **Sufficient**: 매 cause 만 으로 disease (rare in practice).
- **Component**: 매 sufficient cause 의 part (예: 흡연 + asbestos + genetic).
- **Risk factor**: 매 association 만 — causality 의 unconfirmed.
### 매 응용
1. Smoking → lung cancer (Doll & Hill 1950).
2. H. pylori → peptic ulcer (Marshall 1984).
3. HPV → cervical cancer (zur Hausen 2008 Nobel).
4. APOE4 → Alzheimer (genetic risk, not deterministic).
## 💻 패턴
### Bradford Hill scoring
```python
from dataclasses import dataclass
@dataclass
class HillCriteria:
strength: float # RR or OR
consistency: int # # of confirming studies
temporality: bool # exposure precedes outcome
gradient: bool # dose-response
plausibility: bool # mechanism known
coherence: bool # fits prior knowledge
experiment: bool # RCT / natural experiment
specificity: bool
def hill_score(c: HillCriteria) -> int:
score = 0
score += 2 if c.strength >= 3 else 1 if c.strength >= 2 else 0
score += min(c.consistency // 3, 3)
score += [c.temporality, c.gradient, c.plausibility,
c.coherence, c.experiment, c.specificity].count(True)
return score # ≥7 = strong causal evidence
```
### Confounder adjustment via DAG (DoWhy)
```python
import dowhy
from dowhy import CausalModel
model = CausalModel(
data=df,
treatment="smoking",
outcome="lung_cancer",
common_causes=["age", "sex", "ses"],
instruments=["tobacco_tax"],
)
identified = model.identify_effect()
estimate = model.estimate_effect(identified, method_name="backdoor.linear_regression")
refute = model.refute_estimate(identified, estimate, method_name="placebo_treatment_refuter")
```
### Mendelian randomization
```python
# Instrumental variable: SNP → exposure → outcome
# (SNP independent of confounders)
import statsmodels.api as sm
# Wald ratio: beta_outcome / beta_exposure
def mendelian_ratio(snp_exposure_beta: float, snp_outcome_beta: float) -> float:
return snp_outcome_beta / snp_exposure_beta
```
### Population attributable fraction
```python
def paf(prevalence: float, relative_risk: float) -> float:
"""Fraction of disease attributable to exposure in population."""
return prevalence * (relative_risk - 1) / (1 + prevalence * (relative_risk - 1))
# Smoking prevalence 25%, RR for lung cancer 20:
print(paf(0.25, 20)) # ~0.83 → 83% of lung cancer attributable to smoking
```
### Sufficient-component pie visualization
```python
def sufficient_pies(disease: str) -> list[set[str]]:
"""Each pie = a set of component causes that together suffice."""
return [
{"smoking", "genetic_susceptibility"}, # pie 1
{"asbestos", "smoking"}, # pie 2
{"radon", "smoking", "vitamin_deficiency"}, # pie 3
]
```
## 매 결정 기준
| 상황 | Method |
|---|---|
| Single pathogen, acute | Koch postulates (modernized) |
| Chronic, multifactorial | Bradford Hill + Rothman |
| Observational with confounders | DAG + backdoor adjustment |
| Genetic causation suspected | Mendelian randomization |
| RCT impossible (ethics) | quasi-experiment + sensitivity analysis |
**기본값**: 매 Bradford Hill + DAG-based confounder adjustment + sensitivity analysis (E-value).
## 🔗 Graph
- 부모: [[Causal Inference]]
## 🤖 LLM 활용
**언제**: 매 literature synthesis 의 mechanism aggregation, 매 DAG 의 candidate confounder enumeration, 매 sufficient-component 의 component proposal.
**언제 X**: 매 final causation claim 의 LLM 의 의존 — 매 effect estimate 의 source data + statistical method 의 검증 필수.
## ❌ 안티패턴
- **Single-cause thinking**: 매 multifactorial disease 의 monocausal explanation — 매 H. pylori 발견 전 의 stress 의 ulcer 의 단일 cause 의 오해.
- **Correlation = causation**: 매 RR 만 으로 causal claim — 매 confounding, reverse causation, selection bias 의 무시.
- **Ignoring temporality**: 매 cross-sectional study 의 causal direction 의 결정 X.
- **Hill criteria 의 checklist 화**: 매 의 mechanical scoring — 매 viewpoints, not rules (Hill 의 의도).
## 🧪 검증 / 중복
- Verified (Rothman & Greenland "Modern Epidemiology" 4th ed, Hernán & Robins "Causal Inference: What If" 2024, Pearl "Causality" 2nd ed).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Hill criteria, Rothman pies, DAG/MR patterns 추가 |
10_Wiki/Topics/Domain_General/From_Other/Habit-Formation.md
+164
View File
@@ -0,0 +1,164 @@
---
id: wiki-2026-0508-habit-formation
title: Habit Formation
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Habit Loop, Behavior Automation, Habituation]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [psychology, behavior, neuroscience, habits]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: en
framework: behavioral-psychology
---
# Habit Formation
## 매 한 줄
> **"매 habit = cue → routine → reward 의 basal-ganglia automatization"**. 매 21-day myth 의 false — Lally 2010 의 median 66 days (range 18-254). 매 2026 의 wearables + LLM coaching + JITAI (just-in-time adaptive intervention) 의 active.
## 매 핵심
### 매 habit loop (Duhigg / Wood)
1. **Cue**: 매 trigger — time, place, emotional state, preceding action, people.
2. **Routine**: 매 behavior 자체.
3. **Reward**: 매 reinforcement — neural prediction error.
4. **Craving** (Wood addition): 매 anticipation 의 cue→reward.
### 매 neural substrate
- **Goal-directed**: 매 prefrontal + dorsomedial striatum — early learning.
- **Habitual**: 매 dorsolateral striatum (sensorimotor loop) — automatization.
- **Switch**: 매 overtraining + stable context → habitual takeover.
### 매 formation 의 핵심 levers
- **Implementation intentions** (Gollwitzer): "When X, I will Y" — 매 효과 size large (d ≈ 0.65).
- **Context stability**: 매 same time + place 의 consistency.
- **Friction reduction**: 매 cue salience ↑, 매 obstacle ↓.
- **Temptation bundling** (Milkman): 매 desired + pleasurable 결합.
- **Identity-based**: 매 "I am someone who..." (Clear).
### 매 응용
1. Atomic Habits 의 4 laws (obvious, attractive, easy, satisfying).
2. Health behavior change (exercise, medication adherence).
3. Productivity (deep-work blocks).
4. Habit-stacking (after-X-then-Y).
## 💻 패턴
### Habit tracker (streak + context)
```python
from dataclasses import dataclass, field
from datetime import date, timedelta
@dataclass
class HabitLog:
name: str
cue_context: dict # {time, location, preceding_action}
completions: list[date] = field(default_factory=list)
@property
def streak(self) -> int:
if not self.completions:
return 0
s, today = 1, max(self.completions)
for i in range(1, len(self.completions)):
if today - self.completions[-1 - i] == timedelta(days=i):
s += 1
else:
break
return s
```
### Implementation intention generator
```python
def implementation_intention(goal: str, cue: str, action: str) -> str:
return f"When {cue}, I will {action} in service of {goal}."
# When I pour my morning coffee, I will do 10 push-ups in service of strength training.
```
### Habit-stacking chain
```python
def stack(anchor: str, new_habit: str, reward: str | None = None) -> dict:
return {
"anchor": anchor,
"new_habit": new_habit,
"rule": f"After {anchor}, I will {new_habit}.",
"immediate_reward": reward,
}
```
### JITAI delivery decision
```python
def jitai_should_deliver(state: dict) -> bool:
"""Deliver intervention only when receptive + context-matched + low burden."""
return (state["stress"] < 0.7
and state["cognitive_load"] < 0.6
and state["context_match"] > 0.8
and state["recent_interventions_24h"] < 3)
```
### Lally formation curve
```python
import numpy as np
def automaticity(day: int, asymptote: float = 0.95, k: float = 0.04) -> float:
"""Asymptotic automaticity (Lally 2010 fit)."""
return asymptote * (1 - np.exp(-k * day))
# day 21 → ~0.58, day 66 → ~0.88
```
### Context-cue salience score
```python
def cue_salience(cue: dict, history: list[dict]) -> float:
"""Higher when cue co-occurs with successful routine."""
matches = [h for h in history if all(h.get(k) == v for k, v in cue.items())]
if not matches:
return 0.0
return sum(h["completed"] for h in matches) / len(matches)
```
## 매 결정 기준
| 상황 | Strategy |
|---|---|
| Brand-new habit | implementation intention + context stability |
| Existing routine + new addition | habit stacking (anchor) |
| High-friction habit | reduce friction first, then add cue |
| Reward-poor habit | temptation bundling |
| Identity-level change | identity-based ("I am the kind of person who...") |
| Relapse prevention | re-stabilize context, restore cue |
**기본값**: 매 implementation intention + same context daily + 60-90 day window. 매 21-day promise X.
## 🔗 Graph
- 부모: [[Operant_Conditioning|Operant Conditioning]]
- 변형: [[Habit Stacking]]
- 응용: [[CBT]]
- Adjacent: [[Basal Ganglia]] · [[Self-Determination Theory]]
## 🤖 LLM 활용
**언제**: 매 implementation intention drafting, 매 habit-stack anchor 의 brainstorm, 매 obstacle anticipation, 매 daily reflection scaffold.
**언제 X**: 매 individual psychological diagnosis (e.g., compulsion vs habit) — 매 clinical professional 필수.
## ❌ 안티패턴
- **21-day promise**: 매 individual variance 무시 — 매 18-254 day range.
- **Willpower 만 의 의존**: 매 ego depletion + decision fatigue — 매 environment design.
- **Multiple new habits 의 동시**: 매 cognitive bandwidth 초과 — 매 1-2 habits 의 sequence.
- **No cue specification**: 매 vague intention ("eat better") — 매 specific cue + action.
- **Punishing missed days excessively**: 매 self-shame spiral — 매 "miss once, never twice" rule.
## 🧪 검증 / 중복
- Verified (Lally et al. 2010 EJSP, Wood "Good Habits, Bad Habits" 2019, Duhigg "Power of Habit", Clear "Atomic Habits", Gollwitzer 1999 meta-analysis).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — habit loop, Lally curve, JITAI, implementation intentions 추가 |
10_Wiki/Topics/Domain_General/From_Other/Horizontal and Vertical Logic.md
+170
View File
@@ -0,0 +1,170 @@
---
id: wiki-2026-0508-horizontal-and-vertical-logic
title: Horizontal and Vertical Logic
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Pyramid Logic, Minto Pyramid Logic, MECE-Pyramid Structure]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [structured-thinking, pyramid-principle, mece, communication, consulting]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: en
framework: minto-pyramid
---
# Horizontal and Vertical Logic
## 매 한 줄
> **"매 vertical logic = parent ↔ children Q&A coherence; horizontal logic = sibling MECE coherence"**. 매 1973 Barbara Minto (McKinsey) 의 Pyramid Principle 의 dual axis. 매 2026 의 LLM-assisted argument structuring, executive-summary generation, audit findings 의 modern instances.
## 매 핵심
### 매 Vertical logic (Q&A 추적)
- **Top-down**: 매 main idea → child supports through Why?/How?/What?
- **Bottom-up**: 매 children 의 grouping → parent emergence.
- **Test**: 매 each child 의 "answers a Q raised by parent" 의 verify.
### 매 Horizontal logic (sibling coherence)
- **MECE**: 매 mutually exclusive + collectively exhaustive.
- **Inductive**: 매 same-type observations → conclusion.
- **Deductive**: 매 premise 1 + premise 2 → conclusion (max 4 levels).
- **Test**: 매 sibling reorder 시 meaning preserved + no overlap + complete.
### 매 SCQA (Situation-Complication-Question-Answer)
- **Situation**: 매 audience-known background.
- **Complication**: 매 disrupting force.
- **Question**: 매 implicit reader question.
- **Answer**: 매 main idea (top of pyramid).
### 매 응용
1. McKinsey/BCG client deck.
2. Executive memo.
3. Audit / financial reporting.
4. Engineering RFC.
5. LLM 의 reasoning trace structuring.
## 💻 패턴
### Pyramid node tree
```python
from dataclasses import dataclass, field
from typing import Literal
@dataclass
class PyramidNode:
statement: str
logic_type: Literal["inductive", "deductive"] = "inductive"
children: list["PyramidNode"] = field(default_factory=list)
def vertical_test(self) -> bool:
"""Each child must answer Why/How/What raised by self."""
return all(self.statement and c.statement for c in self.children)
def horizontal_test(self) -> bool:
"""MECE: same logical category, no overlap (heuristic check)."""
return len({type(c.statement) for c in self.children}) == 1
```
### MECE category check
```python
def is_mece(items: list[str], categories: dict[str, set[str]]) -> dict:
covered = set().union(*categories.values())
overlaps = [
(a, b) for a in categories for b in categories
if a != b and categories[a] & categories[b]
]
return {
"exhaustive": set(items) <= covered,
"exclusive": not overlaps,
"uncovered": set(items) - covered,
"overlaps": overlaps,
}
```
### Inductive vs deductive selector
```python
def choose_argument_form(num_premises: int, audience_familiarity: float) -> str:
"""Minto: deductive ≤4 levels, only when audience already accepts premises."""
if num_premises <= 3 and audience_familiarity > 0.7:
return "deductive"
return "inductive" # safer default — group similar evidence
```
### SCQA scaffolder
```python
def scqa(situation: str, complication: str, question: str, answer: str) -> str:
return (f"Situation: {situation}\n"
f"Complication: {complication}\n"
f"Question: {question}\n"
f"Answer (main idea): {answer}")
```
### Reorder sibling test (horizontal robustness)
```python
import itertools
def reorder_robust(siblings: list[str], judge_meaning: callable) -> bool:
"""If meaning unchanged across permutations → horizontal logic holds."""
perms = list(itertools.permutations(siblings))[:6]
meanings = {judge_meaning(p) for p in perms}
return len(meanings) == 1
```
### LLM critique pass
```python
from anthropic import Anthropic
client = Anthropic()
def minto_critique(pyramid_yaml: str) -> str:
return client.messages.create(
model="claude-opus-4-7",
max_tokens=2000,
system=("Audit a Minto pyramid. Flag: (1) children that don't answer the "
"Q raised by parent, (2) sibling overlaps (not ME), (3) gaps (not CE), "
"(4) deductive chains beyond 4 levels."),
messages=[{"role": "user", "content": pyramid_yaml}],
).content[0].text
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Executive deck | top-down + SCQA opener |
| Bottom-up synthesis | group findings → emerge top |
| Diagnostic argument | deductive (≤4 levels) |
| Survey / audit findings | inductive (group similar) |
| Confused audience | start with main idea (top) |
**기본값**: 매 top-down 의 vertical structure + inductive 의 horizontal grouping. 매 SCQA 의 opening.
## 🔗 Graph
- 부모: [[Pyramid Principle]]
- 변형: [[Horizontal and Vertical Logic|Horizontal Logic]] (alias) · (alias) · [[MECE]]
- Adjacent: [[SCQA]] · [[Issue Tree]]
## 🤖 LLM 활용
**언제**: 매 draft pyramid 의 critique, 매 MECE gap 의 surface, 매 SCQA 의 opening 작성, 매 inductive grouping 의 candidate.
**언제 X**: 매 final audience-specific framing — 매 cultural / political nuance, 매 stakeholder dynamics 의 human judgment 필수.
## ❌ 안티패턴
- **Bottom of pyramid 부터 발표**: 매 audience 의 main idea 도달 전 fatigue.
- **Mixed inductive + deductive 의 same level**: 매 horizontal coherence 깨짐.
- **5+ siblings**: 매 cognitive overload — 매 7±2 의 lower bound (3-5).
- **MECE 만 의 추구**: 매 forced taxonomy 의 distortion — 매 90% 의 MECE 의 sometimes acceptable.
- **Deductive 의 5+ levels**: 매 reader cognitive load 폭증 — 매 Minto 의 4-level cap.
## 🧪 검증 / 중복
- Verified (Minto "The Pyramid Principle" 3rd ed, McKinsey communication training, Booz Allen 의 SCQA).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — vertical/horizontal axes, MECE, SCQA, Minto pyramid 패턴 추가 |
10_Wiki/Topics/Domain_General/From_Other/Hypostatic-Abstraction.md
+168
View File
@@ -0,0 +1,168 @@
---
id: wiki-2026-0508-hypostatic-abstraction
title: Hypostatic Abstraction
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Hypostasis, Reification, Subjectal Abstraction]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [logic, semiotics, philosophy, peirce, abstraction]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: en
framework: peircean-logic
---
# Hypostatic Abstraction
## 매 한 줄
> **"매 predicate 의 subject 으로 transformation — 'X is honest' → 'X has honesty'"**. 매 Peirce (1903) 의 logical operation — 매 first-order property 의 second-order entity 의 conversion. 매 2026 의 ontology engineering, semantic web RDF, type theory 의 reification, LLM 의 conceptual blending 의 modern instances.
## 매 핵심
### 매 정의 (Peirce)
- **Operation**: 매 "p(x)" → "x has property P" — 매 P 의 noun-form entity.
- **예**:
- "honey is sweet" → "honey has sweetness"
- "the function returns int" → "the function has return-type int"
- "atom is heavy" → "atom has mass"
### 매 distinction from related
- **vs. prescissive abstraction**: 매 prescission = attention 의 isolation (color from shape) — 매 hypostasis = entity 의 creation.
- **vs. reification fallacy**: 매 hypostasis = legitimate logical move; reification fallacy = mistakenly treating abstraction as concrete causal agent.
- **vs. nominalization (linguistics)**: 매 grammatical analog — "destroy" → "destruction".
### 매 utility
- **Reasoning vehicle**: 매 abstract entity 의 quantification 가능 ("there exists a virtue that...").
- **Theory building**: 매 mass, energy, information 의 hypostatic origin.
- **Ontology**: 매 OWL class 의 RDF resource 화.
### 매 응용
1. Math: "function f returns int" → "f has signature ℤ→ℤ".
2. Physics: "object is hot" → "object has temperature T".
3. Law: "act is criminal" → "act has criminality" (mens rea 분석).
4. Programming: type inference 의 reification.
5. Knowledge graph: predicate → resource.
## 💻 패턴
### Predicate to RDF resource (hypostatize)
```python
from rdflib import Graph, URIRef, Literal, RDF
EX = "http://ex.org/"
g = Graph()
# "Alice is honest" → "Alice has honesty(value=true)"
g.add((URIRef(EX + "Alice"), URIRef(EX + "hasVirtue"), URIRef(EX + "Honesty")))
g.add((URIRef(EX + "Honesty"), RDF.type, URIRef(EX + "Virtue")))
```
### Type-level reification (TypeScript)
```typescript
// Before: "f returns number"
function f(x: number): number { return x * 2; }
// Hypostatized: extract the type
type SignatureOf<F> = F extends (...args: infer A) => infer R ? { args: A; ret: R } : never;
type FSig = SignatureOf<typeof f>; // { args: [number]; ret: number }
```
### Predicate → entity (Peircean diagram)
```python
from dataclasses import dataclass
@dataclass
class HypostaticAbstraction:
original_predicate: str # "X is red"
subject_var: str # "X"
abstracted_entity: str # "redness"
relation: str # "has"
def express(self, subject: str) -> tuple[str, str]:
return (
f"{subject} {self.original_predicate.split(' is ')[1]}", # original
f"{subject} {self.relation} {self.abstracted_entity}", # hypostatized
)
h = HypostaticAbstraction("X is red", "X", "redness", "has")
print(h.express("the apple")) # ("the apple red", "the apple has redness")
```
### Detect reification fallacy
```python
def reification_check(claim: str, entity: str) -> bool:
"""Flag if abstract entity assigned causal agency."""
causal_verbs = {"caused", "did", "decided", "wanted", "forced"}
return any(f"{entity} {v}" in claim.lower() for v in causal_verbs)
reification_check("Inflation caused the recession", "inflation") # True (suspect)
```
### Knowledge graph property reification
```turtle
# Direct edge: <Alice> <employs> <Bob>
# Reified (allow metadata on the edge):
:edge1 a rdf:Statement ;
rdf:subject :Alice ;
rdf:predicate :employs ;
rdf:object :Bob ;
:startDate "2024-01-15" ;
:salary 90000 .
```
### LLM hypostatization assistant
```python
from anthropic import Anthropic
client = Anthropic()
def hypostatize(claim: str) -> str:
return client.messages.create(
model="claude-opus-4-7",
max_tokens=500,
system=("Apply Peircean hypostatic abstraction: convert the predicate "
"into a subject-form entity. Then list questions you can now "
"ask of that entity."),
messages=[{"role": "user", "content": claim}],
).content[0].text
```
## 매 결정 기준
| 상황 | When to hypostatize |
|---|---|
| Theory building, want to quantify property | yes |
| Need ontology / KG class | yes |
| Reasoning about types, signatures | yes |
| Granting causal agency to abstraction | NO (reification fallacy) |
| Eliminate redundancy in logic | yes (factor predicate) |
**기본값**: 매 hypostatize 의 explicit + reversible. 매 abstract entity 의 causal agent 화 X.
## 🔗 Graph
- 변형: [[Reification]]
- 응용: [[Ontology Engineering]] · [[Type Theory]]
- Adjacent: [[Conceptual Blending]] · [[Knowledge Graph]]
## 🤖 LLM 활용
**언제**: 매 ontology class 의 candidate 의 surface, 매 vague claim 의 quantifiable property 의 reformulation, 매 nominalization 의 unwind.
**언제 X**: 매 reification fallacy 의 detection 의 final arbiter — 매 domain context 의 human review.
## ❌ 안티패턴
- **Reification fallacy**: 매 abstract entity 의 causal agent 의 treatment ("inflation decided to rise"). 매 actual mechanism 의 obscure.
- **Hypostatic explosion**: 매 every adjective 의 entity 화 — 매 ontology bloat.
- **Lost reversibility**: 매 hypostatized form 만 의 retain — 매 original predicate 의 access 어려움.
- **Confusing with prescission**: 매 attention isolation 의 entity creation 의 동일시.
## 🧪 검증 / 중복
- Verified (Peirce CP 4.235, 5.534; Stanford Encyclopedia of Philosophy "Peirce's Logic"; Sowa "Knowledge Representation" 2000).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Peircean operation, RDF/type reification, fallacy distinction 추가 |
10_Wiki/Topics/Domain_General/From_Other/Improvisation.md
+196
View File
@@ -0,0 +1,196 @@
---
id: wiki-2026-0508-improvisation
title: Improvisation
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Improv, Adaptive Response, Spontaneous Decision-Making]
duplicate_of: none
source_trust_level: B
confidence_score: 0.85
verification_status: applied
tags: [meta, decision-making, agentic, exploration]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: general
---
# Improvisation
## 매 한 줄
> **"매 plan 의 die 매 first contact, 매 improv 매 take over"**. Improvisation 매 real-time adaptive decision-making 매 incomplete information 매 unfolding situation. 2026 LLM agents 매 nontrivial improv capability 의 exhibit — 매 tool failure / unexpected output 의 recover 가능.
## 매 핵심
### 매 Components of improv
- **Situation awareness**: 매 current state 의 fast read.
- **Repertoire**: 매 prelearned moves / patterns.
- **Risk gauge**: 매 reversible vs irreversible 의 distinguish.
- **Commitment**: 매 hesitation 의 X — 매 decide 의 act.
### 매 Plan vs Improv spectrum
- **Pure plan**: scripted, deterministic, fragile.
- **Plan + improv**: skeleton plan + adaptive details (best for most tasks).
- **Pure improv**: jazz solo, emergency response.
- 매 majority production system 매 plan-with-improv-edges.
### 매 LLM agent improvisation
- 매 tool returns unexpected error → reformulate vs fail.
- 매 user gives ambiguous instruction → ask vs guess vs proceed.
- 매 token budget 매 exhaust → compress vs truncate vs delegate.
### 매 응용
1. Incident response (production outage).
2. Live coding session (pair programming).
3. LLM agent error recovery.
4. Customer support edge cases.
## 💻 패턴
### Pattern 1: Repertoire of moves
```python
from typing import Callable
class ImprovKit:
"""매 prelearned moves — 매 situation 의 match 의 dispatch."""
def __init__(self):
self.moves: dict[str, Callable] = {}
def register(self, situation: str, move: Callable):
self.moves[situation] = move
def respond(self, context: dict):
for situation, move in self.moves.items():
if matches(situation, context):
return move(context)
return self.default_move(context)
def default_move(self, context):
return {"action": "ask_for_clarification"}
```
### Pattern 2: Reversibility check before commit
```python
def is_reversible(action: dict) -> bool:
irreversible = {"delete_file", "send_email", "db_drop", "git_push_force"}
return action["type"] not in irreversible
def improv_decide(action: dict, confidence: float) -> str:
if is_reversible(action):
return "act" # 매 try 의 cheap
if confidence > 0.95:
return "act"
return "pause_and_verify"
```
### Pattern 3: LLM error recovery loop
```python
def call_with_improv(client, prompt: str, max_retries: int = 3):
history = [{"role": "user", "content": prompt}]
for attempt in range(max_retries):
try:
return client.messages.create(
model="claude-opus-4-7",
max_tokens=2000,
messages=history,
)
except RateLimitError:
time.sleep(2 ** attempt)
except OverloadedError:
# 매 fallback 매 smaller model
return client.messages.create(
model="claude-haiku-4-7",
max_tokens=2000,
messages=history,
)
except Exception as e:
history.append({
"role": "user",
"content": f"Previous attempt errored: {e}. Try a different approach.",
})
raise RuntimeError("매 improv 의 exhaust")
```
### Pattern 4: Yes-and (improv principle)
```python
def yes_and(user_input: str, context: dict) -> str:
"""매 improv 'Yes, and' — accept premise, build on it."""
return f"Acknowledged: {user_input}. Building on this: {extend(user_input, context)}."
# 매 LLM system prompt 의 embed:
SYSTEM = """매 user 매 partial information 의 give. 매 yes-and 의 follow:
1. Accept what they said as fact (yes).
2. Add useful structure (and).
3. Avoid 'no, that's wrong' unless 매 hard contradiction."""
```
### Pattern 5: Bounded improv (safety rail)
```python
class BoundedImprov:
def __init__(self, max_actions: int = 5, allowed_ops: set = None):
self.max_actions = max_actions
self.allowed_ops = allowed_ops or {"read", "search", "summarize"}
self.actions_taken = 0
def attempt(self, op: str, *args):
if self.actions_taken >= self.max_actions:
raise RuntimeError("매 budget exceed — escalate 의 human")
if op not in self.allowed_ops:
raise PermissionError(f"매 {op} 매 not in improv allowlist")
self.actions_taken += 1
return execute(op, *args)
```
### Pattern 6: Postmortem of improv
```python
def improv_log_entry(situation: str, move: str, outcome: str) -> dict:
return {
"ts": time.time(),
"situation": situation,
"move_chosen": move,
"outcome": outcome,
"would_repeat": outcome in ("success", "partial_success"),
"alternatives_considered": [],
}
# 매 weekly review 매 add successful patterns 의 ImprovKit.
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Reversible action, < 1min | Pure improv. |
| Irreversible, high stakes | Plan first — improv 의 X. |
| Ambiguous user request | Yes-and + clarifying question. |
| LLM tool error | Bounded retry + reformulation. |
| Production incident | Plan (runbook) + improv on edges. |
**기본값**: 매 80/20 — 80% plan, 20% improv 매 unforeseen edges. 매 irreversible 매 strict plan only.
## 🔗 Graph
- 부모: [[Decision-Making]]
- 응용: [[Pair-Programming]]
- Adjacent: [[Risk_Management|Risk-Management]] · [[Bounded_Rationality|Bounded-Rationality]]
## 🤖 LLM 활용
**언제**: Tool error recovery, ambiguous user input handling, edge cases not covered by training data, multi-turn agent self-correction.
**언제 X**: Compliance-critical workflow (deterministic pipeline only), safety-critical irreversible action.
## ❌ 안티패턴
- **Improv on irreversible action**: 매 prod DB drop 의 wing 의 X.
- **No repertoire**: 매 from-scratch every situation — slow + inconsistent.
- **No reversibility check**: 매 acted 매 then-realized too late.
- **Ego improv**: refuse 의 ask for help — 매 stuck-but-improv-ing.
## 🧪 검증 / 중복
- Verified: Keith Johnstone "Impro" (1979), Karl Weick "Organizing for Reliability" (1987), OODA loop (Boyd).
- 신뢰도 B (academic-soft + applied agentic literature).
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full content with LLM agent improv patterns and reversibility framework |
10_Wiki/Topics/Domain_General/From_Other/Interoperability.md
+163
View File
@@ -0,0 +1,163 @@
---
id: wiki-2026-0508-interoperability
title: Interoperability
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Interop, System Integration, Cross-Platform Compatibility]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [systems, protocols, integration, standards]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: multi
framework: standards
---
# Interoperability
## 매 한 줄
> **"매 different systems 가 매 friction 없이 함께 작동하는 능력"**. 매 syntactic (data format), 매 semantic (meaning), 매 organizational (governance) 의 3 layer 로 분해. 매 2026 의 hot topics: MCP (Model Context Protocol), OpenAPI, gRPC, WebAssembly Component Model.
## 매 핵심
### 매 3 layers of interop
- **Syntactic**: 매 byte-level format 의 agreement (JSON, Protobuf).
- **Semantic**: 매 field-meaning 의 agreement (schema + ontology).
- **Organizational**: 매 governance, versioning, deprecation policy.
### 매 enablers
- **Open standards**: HTTP, OpenAPI, JSON-Schema, OAuth 2.1.
- **Schema-first**: Protobuf, Avro, GraphQL SDL.
- **Capability negotiation**: Accept headers, gRPC reflection, MCP capability handshake.
- **Adapter pattern**: 매 N×M integration → N+M with hub.
### 매 응용
1. **AI tool ecosystem**: MCP 매 LLM ↔ tools 의 universal protocol.
2. **Microservices**: gRPC + Protobuf 매 polyglot interop.
3. **Healthcare**: HL7 FHIR 매 EHR interop.
4. **Cross-cloud**: Open Container Initiative (OCI), CNCF standards.
## 💻 패턴
### MCP server (2026 standard)
```python
# Model Context Protocol — Anthropic 2024, ubiquitous in 2026
from mcp.server import Server
from mcp.types import Tool, TextContent
server = Server("my-tool")
@server.list_tools()
async def list_tools() -> list[Tool]:
return [Tool(
name="search",
description="Search the knowledge base",
inputSchema={"type": "object", "properties": {"q": {"type": "string"}}}
)]
@server.call_tool()
async def call_tool(name: str, args: dict) -> list[TextContent]:
if name == "search":
return [TextContent(type="text", text=do_search(args["q"]))]
```
### OpenAPI contract
```yaml
# 매 syntactic + semantic interop in one file
openapi: 3.1.0
info: { title: User API, version: 2.0.0 }
paths:
/users/{id}:
get:
parameters:
- { name: id, in: path, required: true, schema: { type: string } }
responses:
'200':
content:
application/json:
schema: { $ref: '#/components/schemas/User' }
```
### Protobuf schema-first
```protobuf
// user.proto — language-neutral, version-tolerant
syntax = "proto3";
package user.v1;
message User {
string id = 1;
string email = 2;
reserved 3; // 매 deprecated field — 매 forward compat
optional string display_name = 4;
}
```
### Adapter pattern (N+M interop)
```python
class PaymentAdapter:
def charge(self, amount: int, currency: str) -> str: ...
class StripeAdapter(PaymentAdapter):
def charge(self, amount, currency):
return stripe.Charge.create(amount=amount, currency=currency).id
class TossAdapter(PaymentAdapter):
def charge(self, amount, currency):
return toss.payments.confirm(amount=amount).payment_key
```
### Wasm Component Model (2026 cross-language)
```toml
# 매 binary interop — Rust ↔ Python ↔ Go via Wasm components
[package]
name = "my-component"
version = "0.1.0"
[lib]
crate-type = ["cdylib"]
[dependencies]
wit-bindgen = "0.30"
```
## 매 결정 기준
| 상황 | 표준 |
|---|---|
| LLM ↔ tools | MCP |
| REST API contract | OpenAPI 3.1 |
| High-throughput RPC | gRPC + Protobuf |
| Cross-language binary | Wasm Component Model |
| Healthcare data | HL7 FHIR R5 |
| Auth | OAuth 2.1 + OIDC |
**기본값**: 매 schema-first + open standard. 매 proprietary format 의 X.
## 🔗 Graph
- 부모: [[System-Design]] · [[Distributed-Systems]]
- 변형: [[API-Design]]
- 응용: [[MCP]] · [[Protocols]] · [[Microservices]]
## 🤖 LLM 활용
**언제**: 매 protocol selection, 매 schema design review, 매 adapter scaffolding.
**언제 X**: 매 single-team monolith 의 internal modules — over-engineering.
## ❌ 안티패턴
- **Snowflake protocols**: 매 in-house custom protocol → 매 every consumer N×N adapters.
- **Schema drift**: 매 producer / consumer 매 separate schema copies → 매 silent breakage.
- **No versioning**: 매 breaking change broadcast → cascade failure.
- **Tight coupling via DB**: 매 shared DB schema 매 anti-interop.
## 🧪 검증 / 중복
- Verified (W3C, IETF, IEEE standards; Anthropic MCP 2024 spec; gRPC.io; CNCF landscape 2026).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — 3-layer interop, MCP/OpenAPI/Wasm patterns |
10_Wiki/Topics/Domain_General/From_Other/Item-Item-Collaborative-Filtering.md
+186
View File
@@ -0,0 +1,186 @@
---
id: wiki-2026-0508-item-item-collaborative-filterin
title: Item-Item Collaborative Filtering
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Item-Based CF, Item-Item CF, Item Similarity Recommender]
duplicate_of: none
source_trust_level: A
confidence_score: 0.95
verification_status: applied
tags: [recommender-systems, collaborative-filtering, similarity, embeddings]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: scipy
---
# Item-Item Collaborative Filtering
## 매 한 줄
> **"매 user 매 liked X — 매 X 와 similar Y 의 recommend"**. Item-Item CF (Sarwar et al. 2001, Amazon) 매 item 사이 similarity matrix 의 precompute 매 query time 매 user 의 history 의 weighted sum 의 score 의 produce. 2026 매 baseline / cold-start fallback / explainability 매 still widely deployed alongside neural retrievers.
## 매 핵심
### 매 vs User-User CF
- **User-user**: similar users 의 find — 매 user count >>> item count → expensive.
- **Item-item**: similar items 의 find — 매 item catalog 매 stable, similarity 매 precompute-able.
- 매 Amazon 2003 paper: item-item 매 user-user 의 latency / quality 의 dominate.
### 매 Similarity metrics
- **Cosine**: most common, 매 sparse-friendly.
- **Pearson**: mean-centered cosine, 매 rating-bias 의 remove.
- **Adjusted cosine**: user-mean center 매 implicit feedback 매 useful.
- **Jaccard**: binary interactions (clicked / not).
### 매 Scoring formula
- 매 score(u, i) = Σ_{j ∈ N(i) ∩ I_u} sim(i, j) · r(u, j) / Σ |sim(i, j)|.
- N(i) = top-K similar items, I_u = user u 의 interaction set.
### 매 응용
1. Amazon "customers who bought X also bought Y".
2. Netflix similar-titles row.
3. Spotify radio seed expansion.
4. E-commerce cold-start fallback.
## 💻 패턴
### Pattern 1: Sparse cosine similarity (scipy)
```python
import numpy as np
from scipy.sparse import csr_matrix
from sklearn.preprocessing import normalize
def build_item_sim(interactions: csr_matrix, top_k: int = 50) -> csr_matrix:
"""매 interactions: (n_users, n_items). 매 return: (n_items, n_items) top-k similarity."""
# Item vectors = columns
item_norm = normalize(interactions.T, norm="l2", axis=1) # (n_items, n_users)
sim = item_norm @ item_norm.T # (n_items, n_items)
sim.setdiag(0) # self-sim 의 zero
return _keep_topk(sim, top_k)
def _keep_topk(mat: csr_matrix, k: int) -> csr_matrix:
mat = mat.tolil()
for i in range(mat.shape[0]):
row = mat.rows[i]
data = mat.data[i]
if len(data) > k:
idx = np.argsort(data)[-k:]
mat.rows[i] = [row[j] for j in idx]
mat.data[i] = [data[j] for j in idx]
return mat.tocsr()
```
### Pattern 2: Score for a user
```python
def recommend(user_history: dict[int, float], item_sim: csr_matrix, top_n: int = 10):
"""매 user_history: {item_id: rating}. 매 return: top-N (item_id, score)."""
n_items = item_sim.shape[0]
scores = np.zeros(n_items)
sim_sums = np.zeros(n_items)
for j, r in user_history.items():
col = item_sim[:, j].toarray().flatten()
scores += col * r
sim_sums += np.abs(col)
sim_sums[sim_sums == 0] = 1
final = scores / sim_sums
for j in user_history:
final[j] = -np.inf # already-seen 의 mask
top = np.argpartition(final, -top_n)[-top_n:]
return [(int(i), float(final[i])) for i in top[np.argsort(final[top])[::-1]]]
```
### Pattern 3: Implicit feedback (BM25-weighted)
```python
def bm25_weight(interactions: csr_matrix, k1: float = 1.2, b: float = 0.75) -> csr_matrix:
"""매 implicit signal (click count) 의 BM25-style weight 의 give — better than raw counts."""
interactions = interactions.tocsr().astype(float)
N = interactions.shape[0]
df = np.bincount(interactions.indices, minlength=interactions.shape[1])
idf = np.log((N - df + 0.5) / (df + 0.5) + 1)
doc_len = np.asarray(interactions.sum(axis=1)).flatten()
avg_dl = doc_len.mean()
rows, cols = interactions.nonzero()
tf = interactions.data
norm = (1 - b) + b * doc_len[rows] / avg_dl
weighted = tf * (k1 + 1) / (tf + k1 * norm) * idf[cols]
return csr_matrix((weighted, (rows, cols)), shape=interactions.shape)
```
### Pattern 4: Approximate top-K with Faiss (scale)
```python
import faiss
import numpy as np
def build_item_sim_faiss(item_emb: np.ndarray, top_k: int = 50):
"""매 1M+ items 의 scale — exact dot-product 매 too slow."""
n, d = item_emb.shape
item_emb = item_emb / np.linalg.norm(item_emb, axis=1, keepdims=True)
index = faiss.IndexHNSWFlat(d, 32, faiss.METRIC_INNER_PRODUCT)
index.add(item_emb.astype(np.float32))
D, I = index.search(item_emb.astype(np.float32), top_k + 1)
return I[:, 1:], D[:, 1:] # drop self
```
### Pattern 5: Hybrid with content embeddings (cold-start)
```python
def hybrid_sim(cf_sim: np.ndarray, content_sim: np.ndarray, alpha: float = 0.7):
"""매 new item 매 CF 매 zero — 매 content_sim 의 fallback."""
cf_density = (cf_sim != 0).sum(axis=1) / cf_sim.shape[1]
weight = np.where(cf_density > 0.01, alpha, 0.0)[:, None]
return weight * cf_sim + (1 - weight) * content_sim
```
### Pattern 6: 2026 modern stack (neural + item-item)
```python
# 매 production 2026: neural retriever (two-tower) + item-item 매 reranker explainability.
def explain_recommendation(target_item, user_history, item_sim):
"""매 'because you liked X, Y, Z' 매 explanation 의 generate."""
contributions = []
for j, r in user_history.items():
s = item_sim[target_item, j]
contributions.append((j, s * r))
contributions.sort(key=lambda x: -x[1])
return contributions[:3] # top-3 reasons
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| < 100K items, dense matrix fit | Exact cosine + scipy. |
| 1M+ items | Faiss HNSW approximate. |
| Implicit feedback | BM25 weight + cosine. |
| Cold-start items | Content-hybrid sim. |
| Need explainability | Item-item over neural-only. |
| Massive user history | Combine with two-tower neural. |
**기본값**: BM25-weighted cosine + Faiss HNSW (top-50 neighbors), hybrid with content embedding 매 cold-start.
## 🔗 Graph
- 부모: [[Collaborative-Filtering]] · [[Recommender-Systems]]
- 변형: [[Matrix-Factorization]] · [[ALS]]
- 응용: [[Cold-Start]]
- Adjacent: [[Faiss]] · [[BM25]]
## 🤖 LLM 활용
**언제**: Generating explainable recommendations, baseline implementation, hybrid systems where item-item provides interpretability layer.
**언제 X**: Sequential recommendation (use SASRec / transformer), content-rich domains (use embeddings directly).
## ❌ 안티패턴
- **Dense (n_items × n_items) without top-K**: 1M items → 4TB matrix.
- **Cosine on raw counts**: 매 popularity bias — 매 BM25 / TF-IDF 의 weight.
- **No self-mask in scoring**: recommend already-purchased items.
- **Recompute sim every request**: 매 batch precompute 의 cache.
## 🧪 검증 / 중복
- Verified: Sarwar et al. (2001) "Item-based collaborative filtering", Linden et al. (2003) "Amazon.com recommendations", implicit lib (Frederickson 2024).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full content with scipy/Faiss/BM25 patterns and 2026 hybrid stack |
10_Wiki/Topics/Domain_General/From_Other/Joint-Optimization.md
+152
View File
@@ -0,0 +1,152 @@
---
id: wiki-2026-0508-joint-optimization
title: Joint Optimization
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Multi-Objective Optimization, Co-Optimization, End-to-End Optimization]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [optimization, ML, multi-objective]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: pytorch-jax
---
# Joint Optimization
## 매 한 줄
> **"매 multiple objectives / variables 를 동시에 optimize"**. 매 separate / sequential optimization 보다 매 globally better solution 도달 가능 — 매 cost: 매 higher complexity, 매 risk: 매 conflicting gradients. 매 modern DL (end-to-end training), 매 RL (actor-critic), 매 chip design (DSE) 의 매 핵심.
## 매 핵심
### 매 왜 jointly?
- **Coupling**: 매 variables 의 interaction 강 → 매 separate solve 매 suboptimal.
- **Information sharing**: 매 shared representation / gradient → 매 mutual benefit.
- **End-to-end**: 매 pipeline 의 손실 누적 X.
### 매 challenges
- **Conflicting gradients**: 매 objectives 매 push opposite directions.
- **Scaling**: 매 loss magnitudes 매 mismatched → 매 dominant loss problem.
- **Local minima**: 매 joint landscape 매 더 rugged.
- **Compute**: 매 N variables 매 jointly → search space exponential.
### 매 응용
1. **Multi-task learning**: 매 shared encoder + 매 multiple heads.
2. **Actor-critic RL**: 매 policy + value 매 jointly.
3. **HW/SW co-design**: 매 chip floorplan + scheduler 매 jointly.
4. **Pareto front**: 매 cost vs latency 매 frontier.
## 💻 패턴
### Weighted sum (simplest)
```python
import torch
def joint_loss(pred1, pred2, y1, y2, w=(0.5, 0.5)):
l1 = torch.nn.functional.cross_entropy(pred1, y1)
l2 = torch.nn.functional.mse_loss(pred2, y2)
return w[0] * l1 + w[1] * l2
```
### GradNorm (auto-balance)
```python
# Chen et al 2018 — 매 dynamic loss weighting
class GradNorm:
def __init__(self, n_tasks, alpha=1.5):
self.weights = torch.ones(n_tasks, requires_grad=True)
self.alpha = alpha
def update(self, losses, shared_params):
# 매 normalize 매 gradient magnitudes across tasks
grads = [torch.autograd.grad(l, shared_params, retain_graph=True)
for l in losses]
norms = torch.stack([g[0].norm() for g in grads])
target = norms.mean() * (losses / losses.mean()) ** self.alpha
gradnorm_loss = (norms - target.detach()).abs().sum()
return gradnorm_loss
```
### MGDA (Multi-Gradient Descent)
```python
# Sener & Koltun 2018 — 매 Pareto-optimal direction 찾기
import numpy as np
def mgda_solver(grads):
"""grads: list of gradient vectors per task."""
# 매 minimum-norm point in convex hull
G = np.stack([g.flatten() for g in grads])
# solve min ||sum α_i g_i||² s.t. α≥0, sum α=1
from scipy.optimize import minimize
def obj(a): return np.linalg.norm(a @ G) ** 2
a0 = np.ones(len(grads)) / len(grads)
cons = [{"type": "eq", "fun": lambda a: a.sum() - 1}]
bnds = [(0, 1)] * len(grads)
res = minimize(obj, a0, constraints=cons, bounds=bnds)
return res.x # 매 Pareto direction
```
### Actor-critic joint update
```python
# PPO-style joint optimization
def actor_critic_loss(states, actions, advantages, returns, policy, value):
log_p = policy.log_prob(states, actions)
actor_loss = -(log_p * advantages).mean()
critic_loss = (value(states) - returns).pow(2).mean()
entropy = policy.entropy(states).mean()
return actor_loss + 0.5 * critic_loss - 0.01 * entropy
```
### Pareto frontier sampling
```python
# 매 multi-objective 의 frontier 발견
def pareto_front(solutions):
"""solutions: list of (obj1, obj2) tuples (minimize both)."""
front = []
for s in solutions:
dominated = any(
s2[0] <= s[0] and s2[1] <= s[1] and s2 != s
for s2 in solutions
)
if not dominated:
front.append(s)
return front
```
## 매 결정 기준
| 상황 | Strategy |
|---|---|
| 매 objectives 매 aligned | Weighted sum (simple) |
| 매 objectives 매 conflicting | MGDA / PCGrad |
| 매 magnitude 매 mismatched | GradNorm |
| 매 trade-off 매 explore 필요 | Pareto frontier sweep |
| 매 RL actor + critic | Joint PPO/SAC |
**기본값**: Weighted sum 시작 → 매 imbalance 발견시 GradNorm 도입.
## 🔗 Graph
- 부모: [[Optimization]]
- 응용: [[Actor-Critic]]
## 🤖 LLM 활용
**언제**: 매 loss function design 매 multi-objective, 매 gradient conflict diagnosis, 매 Pareto analysis explanation.
**언제 X**: 매 single-objective optimization — over-complication.
## ❌ 안티패턴
- **Random weight tuning**: 매 grid search w/o GradNorm → 매 unstable.
- **Ignore gradient conflict**: 매 cosine(g1,g2) < 0 무시 → 매 destructive interference.
- **Premature joint**: 매 separate pretrain → joint finetune 매 더 좋은 경우 많음.
## 🧪 검증 / 중복
- Verified (Chen 2018 GradNorm; Sener & Koltun 2018 MGDA; Yu 2020 PCGrad; Schulman 2017 PPO).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — multi-objective optimization patterns + Pareto |
10_Wiki/Topics/Domain_General/From_Other/Lucas-Kanade-Method.md
+199
View File
@@ -0,0 +1,199 @@
---
id: wiki-2026-0508-lucas-kanade-method
title: Lucas-Kanade Method
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [LK Optical Flow, Lucas-Kanade Tracker, KLT Tracker]
duplicate_of: none
source_trust_level: A
confidence_score: 0.95
verification_status: applied
tags: [computer-vision, optical-flow, tracking, classical-cv]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: opencv
---
# Lucas-Kanade Method
## 매 한 줄
> **"매 small window, 매 brightness constancy, 매 linear least squares 의 motion vector"**. Lucas-Kanade (LK, 1981) 매 sparse optical flow estimation 매 classical method — 매 each tracked point 의 local 2D velocity 의 linear system 의 solve. 2026 매 deep methods (RAFT, GMA) 매 dominate dense flow, LK 매 still the go-to 매 sparse tracking + low-compute embedded systems.
## 매 핵심
### 매 Assumptions
1. **Brightness constancy**: I(x, y, t) ≈ I(x+dx, y+dy, t+dt).
2. **Small motion**: Taylor expand 매 first-order valid.
3. **Spatial coherence**: small window 매 same motion 의 share.
### 매 The equation
- 매 I_x · u + I_y · v + I_t = 0 (optical flow constraint, per pixel).
- 매 underdetermined (2 unknowns, 1 equation) → window aggregation.
- 매 N pixels in window → over-determined linear system A·d = b.
- 매 d = (Aᵀ A)⁻¹ Aᵀ b (least squares).
### 매 Failure modes
- **Aperture problem**: window 매 1D structure (edge) → A^T A singular.
- **Large motion**: Taylor first-order 매 break — 매 pyramid LK 의 fix.
- **Illumination change**: brightness constancy 매 violate.
- **Occlusion**: tracked point 매 disappear — 매 forward-backward check.
### 매 응용
1. Sparse feature tracking (KLT in SLAM).
2. Video stabilization (camera motion estimation).
3. Embedded vision (drone OF sensor).
4. Initial track for deep refinement.
## 💻 패턴
### Pattern 1: OpenCV calcOpticalFlowPyrLK
```python
import cv2
import numpy as np
cap = cv2.VideoCapture("video.mp4")
ret, prev = cap.read()
prev_gray = cv2.cvtColor(prev, cv2.COLOR_BGR2GRAY)
p0 = cv2.goodFeaturesToTrack(prev_gray, maxCorners=200, qualityLevel=0.01, minDistance=10)
while True:
ret, frame = cap.read()
if not ret:
break
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
p1, status, err = cv2.calcOpticalFlowPyrLK(
prev_gray, gray, p0, None,
winSize=(21, 21), maxLevel=3,
criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 30, 0.01),
)
good = p1[status.flatten() == 1]
prev_gray = gray
p0 = good.reshape(-1, 1, 2)
```
### Pattern 2: Vanilla LK (educational)
```python
import numpy as np
def lucas_kanade(I1, I2, points, window=15):
"""매 each point 의 (u, v) flow vector 의 return."""
half = window // 2
Ix = np.gradient(I1, axis=1)
Iy = np.gradient(I1, axis=0)
It = I2.astype(float) - I1.astype(float)
flow = np.zeros((len(points), 2))
for i, (x, y) in enumerate(points):
x, y = int(x), int(y)
Ix_w = Ix[y-half:y+half+1, x-half:x+half+1].flatten()
Iy_w = Iy[y-half:y+half+1, x-half:x+half+1].flatten()
It_w = It[y-half:y+half+1, x-half:x+half+1].flatten()
A = np.stack([Ix_w, Iy_w], axis=1)
b = -It_w
if np.linalg.matrix_rank(A.T @ A) < 2:
continue # aperture problem
d, *_ = np.linalg.lstsq(A, b, rcond=None)
flow[i] = d
return flow
```
### Pattern 3: Pyramid LK (large motion)
```python
def pyramid_lk(I1, I2, points, levels=4, window=15):
"""매 coarse-to-fine — 매 large motion 의 handle."""
pyr1 = [I1]
pyr2 = [I2]
for _ in range(levels - 1):
pyr1.append(cv2.pyrDown(pyr1[-1]))
pyr2.append(cv2.pyrDown(pyr2[-1]))
flow = np.zeros((len(points), 2))
pts = points / (2 ** (levels - 1))
for level in reversed(range(levels)):
d = lucas_kanade(pyr1[level], pyr2[level], pts, window)
flow = flow * 2 + d
if level > 0:
pts = pts * 2 + d
return flow
```
### Pattern 4: Forward-backward consistency
```python
def fb_consistency(I1, I2, points, threshold=1.0):
"""매 forward 의 track 매 backward 의 verify — 매 lost point 의 reject."""
p1 = points
p2, st_fwd, _ = cv2.calcOpticalFlowPyrLK(I1, I2, p1, None)
p1_back, st_bwd, _ = cv2.calcOpticalFlowPyrLK(I2, I1, p2, None)
err = np.linalg.norm(p1 - p1_back, axis=2).flatten()
valid = (st_fwd.flatten() == 1) & (st_bwd.flatten() == 1) & (err < threshold)
return p2[valid]
```
### Pattern 5: KLT corner re-seeding
```python
def klt_track_with_reseed(cap, max_corners=200, min_count=50):
ret, prev = cap.read()
prev_gray = cv2.cvtColor(prev, cv2.COLOR_BGR2GRAY)
p0 = cv2.goodFeaturesToTrack(prev_gray, max_corners, 0.01, 10)
while True:
ret, frame = cap.read()
if not ret:
break
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
p1, st, _ = cv2.calcOpticalFlowPyrLK(prev_gray, gray, p0, None)
good = p1[st.flatten() == 1]
if len(good) < min_count:
new_pts = cv2.goodFeaturesToTrack(gray, max_corners, 0.01, 10)
good = np.concatenate([good, new_pts.reshape(-1, 2)])
p0 = good.reshape(-1, 1, 2).astype(np.float32)
prev_gray = gray
yield good
```
### Pattern 6: LK 의 deep flow init (2026 hybrid)
```python
# 매 deep model (RAFT) 매 dense flow 의 give — 매 LK 의 sub-pixel refine.
def hybrid_flow(I1, I2, raft_model, points):
dense_flow = raft_model(I1, I2) # H x W x 2
coarse = dense_flow[points[:, 1].astype(int), points[:, 0].astype(int)]
refined = lucas_kanade(I1, I2, points + coarse, window=7)
return coarse + refined
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Sparse feature tracking | KLT (LK + good features). |
| Large motion | Pyramid LK. |
| Dense flow + GPU | RAFT / GMA (deep). |
| Embedded / ms latency | LK 의 stick. |
| Robust tracking | LK + forward-backward + RANSAC. |
**기본값**: `cv2.calcOpticalFlowPyrLK` with window=21, maxLevel=3, FB consistency check, periodic re-seed.
## 🔗 Graph
- 부모: [[Computer Vision|Computer-Vision]]
- 응용: [[KLT-Tracker]]
- Adjacent: [[RAFT]]
## 🤖 LLM 활용
**언제**: Code generation for embedded vision, classical CV pipelines, baseline implementation before deep methods.
**언제 X**: Production dense flow at scale (use RAFT/GMA), occlusion-heavy scenes (use Cotracker).
## ❌ 안티패턴
- **No pyramid for large motion**: 매 LK 매 only handle ~1 pixel motion at single scale.
- **Track forever without re-seed**: 매 features 매 disappear → tracking dies.
- **Ignore aperture problem**: 매 edge-only window → spurious flow.
- **No FB check**: 매 lost points 매 silently track 매 noise.
## 🧪 검증 / 중복
- Verified: Lucas & Kanade (1981) "An iterative image registration technique", Bouguet (2000) pyramid LK, OpenCV docs.
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full content with vanilla LK, pyramid LK, FB consistency, deep hybrid 2026 |
10_Wiki/Topics/Domain_General/From_Other/MECE + Pyramid Principle--.md
+166
View File
@@ -0,0 +1,166 @@
---
id: wiki-2026-0508-mece-pyramid-principle
title: MECE + Pyramid Principle
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [MECE, Pyramid Principle, 미씨 + 피라미드, McKinsey Framework]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [problem-solving, communication, structure, consulting, writing]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: methodology
framework: mckinsey
---
# MECE + Pyramid Principle
## 매 한 줄
> **"매 MECE 는 thinking, Pyramid 는 communication"**. MECE (Mutually Exclusive, Collectively Exhaustive) 는 문제 분해 원칙, Pyramid Principle 은 결론-우선 communication structure. Barbara Minto (1973) 의 McKinsey 표준. 2026 LLM 시대에도 prompt structuring / report writing 의 backbone.
## 매 핵심
### 매 MECE
- **Mutually Exclusive**: 각 카테고리 겹침 없음.
- **Collectively Exhaustive**: 모든 가능성 포함.
- 2x2 matrix, decision tree, issue tree 의 기본.
### 매 Pyramid Principle
- **Top**: governing thought / answer first.
- **Middle**: 3-5 supporting arguments (MECE).
- **Bottom**: data, evidence, examples.
- **SCQA opener**: Situation → Complication → Question → Answer.
### 매 응용
1. Consulting deliverable / executive summary.
2. Research paper structure.
3. LLM prompt design (system + sections).
4. Code review write-up.
## 💻 패턴
### Issue tree decomposition
```python
class Node:
def __init__(self, q, children=None):
self.q = q
self.children = children or []
# Profit decline 분석
tree = Node("Why is profit declining?", [
Node("Revenue down?", [
Node("Volume down?"),
Node("Price down?"),
]),
Node("Cost up?", [
Node("COGS up?"),
Node("OpEx up?"),
]),
])
# 매 each level MECE
```
### MECE validator
```python
def is_mece(categories: list[set]) -> tuple[bool, bool]:
universe = set.union(*categories)
# ME: pairwise disjoint
me = all(not (a & b) for i, a in enumerate(categories)
for b in categories[i+1:])
# CE: union covers universe
ce = set.union(*categories) == universe
return me, ce
```
### Pyramid outliner (LLM)
```python
def pyramid_outline(question: str) -> dict:
prompt = f"""Structure as Pyramid Principle:
1. Governing answer (1 sentence).
2. 3 MECE supporting arguments.
3. For each, 2-3 evidence bullets.
Question: {question}
Output JSON."""
resp = client.messages.create(
model="claude-opus-4-7",
max_tokens=2048,
messages=[{"role": "user", "content": prompt}],
)
return json.loads(resp.content[0].text)
```
### SCQA opener generator
```python
def scqa(situation, complication, question, answer):
return (
f"**Situation**: {situation}\n"
f"**Complication**: {complication}\n"
f"**Question**: {question}\n"
f"**Answer**: {answer}"
)
```
### 2x2 framework
```python
def matrix_2x2(items, axis_x, axis_y):
quadrants = {"high-high": [], "high-low": [],
"low-high": [], "low-low": []}
for item in items:
x = "high" if axis_x(item) else "low"
y = "high" if axis_y(item) else "low"
quadrants[f"{x}-{y}"].append(item)
return quadrants
```
### Top-down report builder
```python
def build_report(answer, args: list[dict]):
out = [f"# {answer}\n"]
for i, arg in enumerate(args, 1):
out.append(f"## {i}. {arg['claim']}")
for ev in arg["evidence"]:
out.append(f"- {ev}")
return "\n".join(out)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Problem decomposition | Issue tree (MECE at each level) |
| Executive deck | Pyramid + SCQA + 3 args |
| Categorization | 2x2 matrix or MECE list |
| LLM task | Pyramid in system prompt |
**기본값**: Issue tree 분석 → Pyramid 로 communicate.
## 🔗 Graph
- 부모: [[Problem Solving Process]]
- 변형: [[Pyramid Principle]] · [[Issue Tree]]
- 응용: [[Technical Writing]]
- Adjacent: [[Hypothesis-Driven]]
## 🤖 LLM 활용
**언제**: report drafting, prompt structuring, decomposition assistance.
**언제 X**: creative / divergent ideation — 매 over-constrains.
## ❌ 안티패턴
- **False MECE**: overlap 있는데 disjoint 라 가정.
- **Bottom-up dump**: data 먼저 늘어놓고 conclusion 마지막 → executive 가 lost.
- **Over-decomposition**: 7+ branches at one level → cognitive overload.
- **Forced 3 categories**: 매 항상 3 으로 강제 → exhaustiveness 깨짐.
## 🧪 검증 / 중복
- Verified (Minto 1973 "The Pyramid Principle", McKinsey training docs, HBR 2019).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — issue tree + SCQA + 2x2 패턴 |
10_Wiki/Topics/Domain_General/From_Other/MMORPG 영속적 세계와 자원 관리.md
+32
View File
@@ -0,0 +1,32 @@
---
id: wiki-2026-0508-mmorpg-영속적-세계와-자원-관리
title: MMORPG 영속적 세계와 자원 관리
category: 10_Wiki/Topics
status: duplicate
canonical_id: mmorpg-persistent-world
duplicate_of: "[[MMORPG Persistent World Design]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, mmorpg, game-design]
last_reinforced: 2026-05-10
github_commit: pending
---
# MMORPG 영속적 세계와 자원 관리
> **이 문서는 [[MMORPG Persistent World Design]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- **Persistent state**: server-authoritative DB, player offline 시에도 world state 진행.
- **Resource sinks/faucets**: economy 균형 (gold sink: repair, faucet: quest reward).
- **Sharding**: per-region 또는 dynamic instance 로 scalability.
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/Middle-Out-Thinking.md
+140
View File
@@ -0,0 +1,140 @@
---
id: wiki-2026-0508-middle-out-thinking
title: Middle Out Thinking
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Middle-Out Reasoning, Anchor-First Design]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [thinking, problem-solving, design]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: conceptual
framework: methodology
---
# Middle Out Thinking
## 매 한 줄
> **"매 problem-solving은 middle anchor에서 시작한다"**. 매 top-down (high-level vision)도 bottom-up (raw details)도 아닌, 매 가장 stable / well-understood 한 layer에서 양방향으로 expand 하는 reasoning approach. 매 Silicon Valley series 의 fictional compression 농담에서 시작해 매 product design / ML architecture / writing 의 real methodology 로 자리 잡았다.
## 매 핵심
### 매 왜 middle 인가
- Top-down: 매 vision 명확하지만 매 details 의 unknown 많음 → premature commitment.
- Bottom-up: 매 details 견고하지만 매 coherence 부재 → integration hell.
- Middle-out: 매 anchor (가장 잘 아는 layer) 부터 매 outward expansion → matched uncertainty.
### 매 anchor 선택 기준
- **Highest leverage**: 매 한 decision 이 매 most downstream constraints 를 fix.
- **Most certain**: 매 well-known domain / proven pattern.
- **Bidirectional**: 매 위로 (abstraction)도 매 아래로 (implementation)도 expand 가능.
### 매 응용
1. **Product**: MVP feature 매 core user job 부터 → upward (positioning), downward (UI tech).
2. **ML architecture**: 매 backbone (e.g., Transformer block) 매 anchor → upward (training loop), downward (kernel ops).
3. **Writing**: 매 thesis sentence 매 middle → upward (intro/conclusion), downward (evidence).
## 💻 패턴
### Anchor identification
```python
# Middle-out planning helper
def identify_anchor(problem: dict) -> str:
"""매 highest-leverage + most-certain layer 찾기."""
candidates = problem["layers"]
scored = [
(layer, layer["leverage"] * layer["certainty"])
for layer in candidates
]
scored.sort(key=lambda x: -x[1])
return scored[0][0]["name"]
```
### Bidirectional expansion
```python
def expand(anchor: str) -> dict:
upward = derive_abstractions(anchor) # vision, goals
downward = derive_implementations(anchor) # mechanisms
return {"up": upward, "down": downward, "anchor": anchor}
```
### Middle-out PR description
```markdown
## Anchor (middle)
변경의 핵심: <one sentence>
## Up (why)
- Business / product reason
- User-facing impact
## Down (how)
- Implementation detail 1
- Implementation detail 2
```
### Architecture sketch (ML)
```python
# Anchor: TransformerBlock
class TransformerBlock(nn.Module):
def __init__(self, d, h):
super().__init__()
self.attn = MultiHeadAttn(d, h)
self.ff = FeedForward(d)
def forward(self, x):
return self.ff(self.attn(x))
# Up: stack into model
# Down: choose attention kernel (FlashAttn vs naive)
```
### Document outline tool
```python
def middle_out_outline(thesis: str):
return {
"thesis": thesis, # anchor
"intro": "[derive from thesis]",
"body": "[decompose thesis into 3 claims]",
"conclusion": "[restate + extend]",
}
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 vision 명확, 매 details 의 unknown | Middle-out (anchor at known mid layer) |
| 매 details 의 강제 (HW constraint) | Bottom-up |
| 매 brand-new domain, 매 nothing known | Top-down + spike |
| 매 refactor existing system | Middle-out (anchor at stable interface) |
**기본값**: Middle-out — 매 most realistic problems 에서 매 anchor 가 존재.
## 🔗 Graph
- 부모: [[Problem_Solving|Problem-Solving]] · [[Design Thinking]]
- 변형: [[Top-Down-Design]] · [[Bottom-Up-Design]]
- 응용: [[Minimal-Viable-Product]]
- Adjacent: [[Pyramid Principle]]
## 🤖 LLM 활용
**언제**: 매 ambiguous spec 에서 매 LLM 에게 "what's the anchor?" 질문 → 매 most leveraged decision 부터 elaborate.
**언제 X**: 매 trivial well-defined task — 매 직접 implementation 이 빠름.
## ❌ 안티패턴
- **Anchor too high**: 매 vision-level anchor → 매 bottom-up과 동일하게 details 폭발.
- **Anchor too low**: 매 implementation-level anchor → 매 top-down 부재로 coherence 상실.
- **Multiple anchors**: 매 simultaneous 의 multiple middle 선택 → 매 expansion conflict.
## 🧪 검증 / 중복
- Verified (Pyramid Principle, Minto 1987; Architectural Decision Records practice).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — anchor-first reasoning methodology with bidirectional expansion |
10_Wiki/Topics/Domain_General/From_Other/NDF (Neutral Data Format).md
+181
View File
@@ -0,0 +1,181 @@
---
id: wiki-2026-0508-ndf-neutral-data-format
title: NDF (Neutral Data Format)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Neutral Data Format, Eugen NDF, WARNO NDF]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [modding, data-format, eugen-systems, warno, configuration]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: NDF
framework: Eugen-Iriszoom
---
# NDF (Neutral Data Format)
## 매 한 줄
> **"매 declarative game-data DSL — Eugen Systems Iriszoom engine 의 data layer"**. 매 Wargame/Steel Division/WARNO 시리즈 의 unit/weapon/visual 의 모든 stat 의 NDF 파일 정의. 매 modding 의 entry point — 매 binary patch 가 X, plain text 의 git-diffable.
## 매 핵심
### 매 Syntax 의 핵심
- **Object literal**: `Identifier is TYPE(...)` — 매 모든 entity 의 declaration.
- **Module 의 nesting**: 매 outer module 안의 inner objects 의 reference.
- **Reference**: `~/Module/Path/Identifier` — 매 absolute paths.
- **Map / List**: `MAP[(key, value), ...]`, `[item1, item2]`.
- **Comment**: `//` (line) — 매 `/* */` 의 X.
### 매 typical structure
- **GameData**: 매 unit definitions / weapon stats / texture references / sound mappings.
- **Module**: 매 named container — 매 `ZModule_TWeaponManagerModuleDescriptor` 의 sort 의 component.
- **Inheritance**: 매 `is BaseType(...)` 의 prototype 의 from inheritance — override fields only.
### 매 응용
1. **Unit balance modding** (HP / armor / damage tweaks).
2. **New unit creation** (copy/paste/rename + export to deck).
3. **Visual mod** (camo swap, model substitution via NDF reference change).
## 💻 패턴
### 매 NDF 의 unit definition (WARNO style)
```ndf
// Unit declaration with module composition
TUniteDescriptor_M1Abrams is TUniteDescriptor
(
ClassNameForDebug = "M1A1 Abrams"
AcknowUnitType = ~/AcknowUnitType_Tank
ModulesDescriptors =
[
TBaseDamageModuleDescriptor
(
MaxPhysicalDamages = 9
ArmorDescriptorFront = ~/Armor_Tank_Heavy_Front
ArmorDescriptorSides = ~/Armor_Tank_Heavy_Side
),
TWeaponManagerModuleDescriptor
(
Salves = [1, 1, 1]
TurretDescriptorList = [TTurretInfanterieDescriptor()]
),
]
)
```
### 매 NDF parser (Python — ndf-parse 패키지)
```python
import ndf_parse
import ndf_parse.model as ndf_model
# Parse a WARNO NDF file
with open("UniteDescriptor.ndf") as f:
source = f.read()
tree = ndf_parse.parse(source)
# Find Abrams unit and tweak HP
for obj in tree:
if obj.namespace == "TUniteDescriptor_M1Abrams":
damage_mod = obj.value.by_member("ModulesDescriptors").value[0]
damage_mod.value.by_member("MaxPhysicalDamages").value = "12"
# Write back
with open("UniteDescriptor.modified.ndf", "w") as f:
f.write(ndf_parse.print_tree(tree))
```
### 매 batch 의 unit stat 의 audit
```python
import ndf_parse
from pathlib import Path
def audit_unit_hp(ndf_dir: Path) -> dict[str, int]:
"""Scan all unit descriptors and extract MaxPhysicalDamages."""
results = {}
for ndf_path in ndf_dir.glob("**/UniteDescriptor*.ndf"):
tree = ndf_parse.parse(ndf_path.read_text(encoding="utf-8"))
for obj in tree:
if obj.value.type == "TUniteDescriptor":
try:
mods = obj.value.by_member("ModulesDescriptors").value
for m in mods:
if m.value.type == "TBaseDamageModuleDescriptor":
hp = int(m.value.by_member("MaxPhysicalDamages").value)
results[obj.namespace] = hp
except (AttributeError, KeyError):
pass
return results
hp_table = audit_unit_hp(Path("./WARNO_GameData/Generated/Gameplay/Gfx"))
# Find outliers
for unit, hp in sorted(hp_table.items(), key=lambda x: -x[1])[:10]:
print(f"{unit}: {hp}")
```
### 매 mod 의 inheritance (override only what changed)
```ndf
// Mod file — overrides base unit
export TUniteDescriptor_M1Abrams_Modded is TUniteDescriptor_M1Abrams
(
// Only override the fields you change
Modifications =
[
("MaxPhysicalDamages", 15), // buff HP
("MaxSpeedInKmph", 75), // faster
]
)
```
### 매 NDF 의 git-friendly diff
```bash
# Mod versioning workflow
git init mods/abrams_buff
cd mods/abrams_buff
cp ../../WARNO_GameData/Generated/Gameplay/Gfx/UniteDescriptor.ndf base.ndf
# ... edit ...
git diff base.ndf modified.ndf > abrams_buff.patch
# Reapply on update
git apply abrams_buff.patch # works as long as upstream context stable
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 single value tweak | Direct edit + diff |
| 매 systematic balance pass | ndf-parse Python script |
| 매 new unit | Inherit from existing TUniteDescriptor + override |
| 매 cross-version mod | `Modifications = [...]` override list (resilient to base changes) |
| 매 visual-only mod | Texture path swap in TextureBank NDF |
**기본값**: 매 inheritance + Modifications list — 매 maintainability 의 best.
## 🔗 Graph
- 부모: [[Eugen Systems 모딩 매뉴얼]] · [[Iriszoom 엔진]]
- 변형: [[ndf-parse 패키지]] · [[WARNO Modding]]
## 🤖 LLM 활용
**언제**: 매 large balance pass (parse → batch edit → write) / 매 new unit boilerplate generation / 매 cross-mod conflict detection.
**언제 X**: 매 tiny single-value edit — 매 manual edit 의 faster.
## ❌ 안티패턴
- **매 binary patch**: 매 game patches 의 break — NDF 의 source-level 의 stay.
- **매 full file 의 copy**: 매 base game patch 의 conflict — Modifications override list 의 use.
- **매 string concat 의 NDF generation**: 매 syntax error 의 risk — proper parser library 의 use.
- **매 무 backup**: 매 NDF 의 game crash 시 root cause — git-track everything.
## 🧪 검증 / 중복
- Verified (Eugen Systems WARNO modding documentation; ndf-parse Python package on PyPI; community Discord patterns).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — NDF syntax + ndf-parse patterns + modding workflow |
10_Wiki/Topics/Domain_General/From_Other/Neurobiology-of-Reward.md
+131
View File
@@ -0,0 +1,131 @@
---
id: wiki-2026-0508-neurobiology-of-reward
title: Neurobiology of Reward
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Reward System, Dopamine System, Mesolimbic Pathway]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [neuroscience, reward, dopamine, RL]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: neuroscience-RL
---
# Neurobiology of Reward
## 매 한 줄
> **"매 dopamine 은 reward 자체 X, 매 reward prediction error 의 signal"**. 매 mesolimbic pathway (VTA → NAc) 가 매 expected vs actual outcome 의 차이를 encode 하며, 매 Schultz (1997) 가 매 발견. 매 modern RL (TD-learning, RLHF) 의 매 biological 의 root.
## 매 핵심
### 매 핵심 회로
- **VTA (ventral tegmental area)**: 매 dopamine 의 source neurons.
- **NAc (nucleus accumbens)**: 매 reward salience encoding.
- **PFC (prefrontal cortex)**: 매 value-based decision-making.
- **Amygdala**: 매 valence (positive/negative) encoding.
### 매 RPE (Reward Prediction Error)
- 매 RPE = actual_reward - expected_reward.
- 매 positive RPE → dopamine burst → 매 reinforce action.
- 매 negative RPE → dopamine dip → 매 weaken action.
- 매 zero RPE (fully predicted reward) → no signal.
### 매 응용
1. **RL algorithms**: TD-learning 매 RPE 와 mathematically equivalent.
2. **RLHF**: 매 reward model 매 human preference RPE 의 proxy.
3. **Addiction research**: 매 hijacked dopamine → compulsive behavior.
4. **UX design**: 매 variable reward schedule (slot machine effect).
## 💻 패턴
### TD-learning (Sutton & Barto, RL biological analog)
```python
# Temporal Difference learning — RPE 매 update signal
import numpy as np
def td_update(V, state, next_state, reward, alpha=0.1, gamma=0.99):
"""V[s] ← V[s] + α(r + γV[s'] - V[s])"""
rpe = reward + gamma * V[next_state] - V[state] # 매 RPE
V[state] += alpha * rpe
return V, rpe
```
### Dopamine neuron simulation
```python
def dopamine_response(predicted_r, actual_r, baseline=1.0):
"""Schultz (1997) — 매 phasic firing rate."""
rpe = actual_r - predicted_r
return baseline * np.exp(rpe) # scale baseline firing
```
### RLHF reward model (modern bridge)
```python
# transformers + trl
from trl import PPOTrainer, PPOConfig
from transformers import AutoModelForCausalLMWithValueHead
# 매 reward model = learned approximation of human RPE
config = PPOConfig(model_name="meta-llama/Llama-3.1-8B")
trainer = PPOTrainer(config, model, tokenizer, reward_model=reward_fn)
# Reward signal drives policy update → analog of dopamine update
```
### Variable reward schedule (UX)
```python
import random
def variable_reward(action_count):
"""매 intermittent reinforcement — strongest learning."""
if random.random() < 0.3: # 30% reward
return "reward"
return "no_reward"
```
### Aversive learning (negative valence)
```python
def negative_rpe_update(V, s, s_, r, alpha=0.1):
"""매 amygdala-mediated learning."""
rpe = r + V[s_] - V[s] # r typically negative
V[s] += alpha * rpe
return V
```
## 매 결정 기준
| 질문 | 답 |
|---|---|
| 매 dopamine 매 pleasure 인가? | X — RPE signal (wanting ≠ liking) |
| 매 RL 의 reward 매 dopamine? | Functional analog yes (Schultz) |
| 매 addiction 매 dopamine 과잉? | X — dysregulated RPE / hijacked salience |
| 매 RLHF 매 brain-like? | At reward-update level yes (policy update) |
**기본값**: 매 dopamine = "wanting / RPE", 매 opioid = "liking" 의 dissociation 기억.
## 🔗 Graph
- 부모: [[Reinforcement-Learning]]
- 응용: [[RLHF]] · [[TD-Learning]] · [[Addiction]]
- Adjacent: [[Operant-Conditioning]] · [[Habit-Formation]]
## 🤖 LLM 활용
**언제**: 매 reward modeling intuition, 매 RLHF reward shaping debugging, 매 motivation framework explanation.
**언제 X**: 매 clinical psychiatry — 매 specialist 영역.
## ❌ 안티패턴
- **Dopamine = pleasure**: 매 popular myth — 실제는 RPE / wanting.
- **More dopamine = better**: 매 tonic 과잉 매 schizophrenia, parkinson off-state.
- **Reward hacking**: 매 RL agent 매 RPE exploit, 매 brain analog (addiction).
## 🧪 검증 / 중복
- Verified (Schultz 1997 *Science*; Berridge & Robinson 1998 wanting/liking; Sutton & Barto *RL Book* 2018 2e).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — RPE biology + RL bridge + RLHF analog |
10_Wiki/Topics/Domain_General/From_Other/Neuroergonomics.md
+144
View File
@@ -0,0 +1,144 @@
---
id: wiki-2026-0508-neuroergonomics
title: Neuroergonomics
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Neuro-Ergonomics, Brain at Work, Cognitive Ergonomics]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [neuroergonomics, hci, cognitive-load, fnirs, eeg]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: mne-python
---
# Neuroergonomics
## 매 한 줄
> **"매 brain at work — 매 neural signals 의 measure, 매 system 의 adapt"**. 매 2003 Parasuraman 의 coin, 매 fNIRS/EEG/eye-tracking 의 mature. 매 2026 의 closed-loop adaptive systems (cockpits, surgery, AR work) 의 deploy.
## 매 핵심
### 매 measurement modalities
- **EEG**: 매 ms-level temporal resolution. 매 cognitive load 의 alpha-suppression / theta-Fz 의 marker.
- **fNIRS**: 매 cortex hemodynamics. 매 portable, motion-tolerant — 매 real-world 의 work.
- **Eye tracking**: 매 fixation duration, pupil dilation — 매 mental effort 의 proxy.
- **HRV / GSR**: 매 ANS arousal — 매 stress / engagement.
### 매 cognitive states 의 detect
- **Workload**: 매 over-load → 매 error spike. 매 under-load → 매 vigilance drop.
- **Vigilance / fatigue**: 매 P300 amplitude decline + theta increase.
- **Engagement / flow**: 매 mid-frontal theta + alpha asymmetry.
### 매 응용
1. 매 adaptive cockpit (Airbus, Honeywell): 매 pilot workload 의 high → 매 secondary task 의 defer.
2. 매 surgical training: 매 trainee fNIRS prefrontal 의 over-activation = novice marker.
3. 매 driver-state monitoring (Tesla v13, Mercedes Drive Pilot): 매 EEG drowsiness 의 detect.
## 💻 패턴
### EEG workload index (theta/alpha ratio)
```python
import mne, numpy as np
raw = mne.io.read_raw_brainvision('subj.vhdr', preload=True)
raw.filter(1, 40)
psd = raw.compute_psd(fmin=4, fmax=12, picks=['Fz', 'Pz'])
freqs = psd.freqs
power = psd.get_data() # (channels, freqs)
theta = power[:, (freqs >= 4) & (freqs < 8)].mean(axis=1)
alpha = power[:, (freqs >= 8) & (freqs < 13)].mean(axis=1)
workload_index = theta / alpha # higher = more load
```
### fNIRS prefrontal activation (MNE-NIRS)
```python
from mne_nirs.experimental_design import make_first_level_design_matrix
from mne_nirs.statistics import run_glm
raw_haemo = mne.preprocessing.nirs.beer_lambert_law(raw_od, ppf=0.1)
design = make_first_level_design_matrix(raw_haemo, drift_model='cosine')
glm = run_glm(raw_haemo, design)
# beta for HbO in PFC channels = task-evoked activation
pfc_activation = glm.to_dataframe().query("ch_name.str.contains('S1_D1') & Chroma=='hbo'")
```
### Pupil-based effort (PsychoPy + Pupil Labs)
```python
import zmq, msgpack
ctx = zmq.Context(); sub = ctx.socket(zmq.SUB)
sub.connect('tcp://127.0.0.1:50020'); sub.setsockopt_string(zmq.SUBSCRIBE, 'pupil')
while True:
topic, payload = sub.recv_multipart()
msg = msgpack.unpackb(payload)
if msg['confidence'] > 0.8:
diameter_mm = msg['diameter_3d']
# baseline-corrected pupil dilation = effort proxy
```
### Closed-loop adaptive UI (workload-triggered)
```python
class AdaptiveDashboard:
def tick(self, workload_idx: float):
if workload_idx > 1.5: # high load
self.hide_secondary_widgets()
self.enlarge_primary_alert()
elif workload_idx < 0.6: # under-load → boredom
self.inject_status_check()
else:
self.restore_default()
```
### Drowsiness detector (real-time EEG)
```python
from scipy.signal import welch
def is_drowsy(eeg_window, fs=256):
f, P = welch(eeg_window, fs=fs, nperseg=fs*2)
theta = P[(f>=4)&(f<8)].mean()
beta = P[(f>=13)&(f<30)].mean()
return (theta / beta) > 4.0 # KSS-validated threshold
```
### NASA-TLX subjective + neural fusion
```python
def fused_workload(neural_idx: float, tlx_score: float) -> float:
# weight neural higher when within-subject calibrated
return 0.6 * neural_idx_z + 0.4 * (tlx_score / 100)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Lab, high precision needed | EEG (32-64ch) + eye-track |
| Field / mobile work | fNIRS + wearable HRV |
| Driver / pilot | Webcam-pupil + steering-entropy + PERCLOS |
| Long shift fatigue | Actigraphy + HRV + PVT |
**기본값**: fNIRS + eye-tracking — 매 real-world ecological validity 의 best.
## 🔗 Graph
- 변형: [[Affective Computing]] · [[Brain-Computer-Interface]]
## 🤖 LLM 활용
**언제**: 매 study design review, 매 GLM script generation, 매 multimodal-feature engineering, 매 paper synthesis.
**언제 X**: 매 raw artifact rejection, 매 individual-subject calibration — 매 expert review 의 require.
## ❌ 안티패턴
- **Single-modality reliance**: 매 EEG-only 의 motion artifact 에 fragile. 매 fusion 의 require.
- **No baseline**: 매 absolute power 의 between-subject 의 noisy. 매 within-subject z-score 의 use.
- **Open-loop dashboard**: 매 measure-but-not-act → 매 value 의 zero. 매 closed-loop 의 design.
- **No personalization**: 매 group-mean threshold 의 50% individuals 에 wrong.
## 🧪 검증 / 중복
- Verified (Parasuraman & Rizzo 2007 *Neuroergonomics*; Ayaz & Dehais 2019).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — modalities + closed-loop adaptive patterns |
10_Wiki/Topics/Domain_General/From_Other/Neuromuscular-Control.md
+143
View File
@@ -0,0 +1,143 @@
---
id: wiki-2026-0508-neuromuscular-control
title: Neuromuscular Control
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [신경근 조절, Motor Control, NMS Control]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [neuroscience, biomechanics, motor-control, robotics, biomedical]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: opensim
---
# Neuromuscular Control
## 매 한 줄
> **"매 brain plans, spine reflexes, muscle executes"**. Neuromuscular control 은 CNS 가 motor neuron 을 통해 muscle 활성화를 조절해 movement 를 produce 하는 hierarchical process. 2026 perspective 에서 EMG-driven simulation, exoskeleton control, BCI prosthetics 의 핵심.
## 매 핵심
### 매 hierarchy
- **Cortex (M1, PMC, SMA)**: motor planning.
- **Cerebellum**: timing, coordination, error correction.
- **Basal ganglia**: action selection, gain modulation.
- **Spinal cord**: reflex circuits, central pattern generators (CPG).
- **Motor unit**: α-MN + muscle fibers (final common pathway).
### 매 control principles
- **Size principle (Henneman)**: small MN 먼저, large 나중.
- **Co-contraction**: agonist + antagonist 동시 활성화 → stiffness 조절.
- **Stretch reflex**: muscle spindle Ia → α-MN monosynaptic.
- **Equilibrium point hypothesis**: descending command = desired length.
### 매 응용
1. Prosthetic / exoskeleton control.
2. Rehabilitation robotics.
3. Surgical motor mapping.
4. Sport biomechanics.
## 💻 패턴
### Hill-type muscle model
```python
import numpy as np
def hill_muscle(activation, length, velocity,
F_max=1000, l_opt=0.1, v_max=10):
f_l = np.exp(-((length - l_opt) / (0.5 * l_opt))**2)
if velocity <= 0:
f_v = (v_max + velocity) / (v_max - 4 * velocity)
else:
f_v = (1.8 - 0.8 * (v_max + velocity) / (v_max - 7.56 * velocity))
return F_max * activation * f_l * f_v
```
### Motor unit recruitment (size principle)
```python
def recruit(excitation, n_units=100, threshold_max=1.0):
thresholds = np.linspace(0.05, threshold_max, n_units)
return np.where(excitation > thresholds,
(excitation - thresholds) / (1 - thresholds), 0)
```
### EMG → activation mapping
```python
from scipy.signal import butter, filtfilt
def emg_to_activation(emg_raw, fs=1000):
b, a = butter(4, [20, 450], btype="band", fs=fs)
emg = filtfilt(b, a, emg_raw)
emg = np.abs(emg)
b, a = butter(4, 6, btype="low", fs=fs)
env = filtfilt(b, a, emg)
return env / env.max()
```
### Inverse dynamics (joint torque)
```python
def inverse_dynamics(theta, theta_dot, theta_ddot, m=5, l=0.4, g=9.81):
I = m * l**2 / 3
return I * theta_ddot + 0.5 * m * g * l * np.sin(theta)
```
### CPG (Matsuoka oscillator)
```python
def matsuoka_step(x1, x2, v1, v2, u=1.0, beta=2.5, tau=0.1, dt=0.001):
y1, y2 = max(0, x1), max(0, x2)
dx1 = (-x1 - beta*v1 - 2.0*y2 + u) / tau
dx2 = (-x2 - beta*v2 - 2.0*y1 + u) / tau
dv1 = (-v1 + y1) / (tau * 12)
dv2 = (-v2 + y2) / (tau * 12)
return x1 + dx1*dt, x2 + dx2*dt, v1 + dv1*dt, v2 + dv2*dt
```
### EMG-driven prosthetic control
```python
class MyoelectricController:
def __init__(self, n_channels=8):
self.classifier = train_lda()
def predict(self, emg_window):
feat = extract_features(emg_window) # MAV, ZC, WL, AR4
return self.classifier.predict(feat)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Whole-body simulation | OpenSim / MyoSuite |
| Single joint, real-time | Hill-type + LDA EMG |
| Locomotion robot | CPG + reflexes |
| Pathology study | Inverse dynamics + EMG |
**기본값**: Hill-type muscle + size-principle recruitment + EMG envelope.
## 🔗 Graph
- 변형: [[Perceptual-Motor-Skills]]
- Adjacent: [[Reinforcement Learning]] · [[BCI]]
## 🤖 LLM 활용
**언제**: simulation parameter tuning, EMG feature engineering, paper synthesis.
**언제 X**: clinical motor diagnosis — neurologist 필수.
## ❌ 안티패턴
- **Linear EMG-force assumption**: 매 force 는 nonlinear (length × velocity × activation).
- **Ignoring co-contraction**: stiffness control 무시 → unstable model.
- **Pure feedback control**: feed-forward (internal model) 누락 → laggy.
## 🧪 검증 / 중복
- Verified (Zajac 1989, Delp OpenSim 2018, Henneman 1965).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Hill model + EMG + CPG 패턴 |
10_Wiki/Topics/Domain_General/From_Other/Neuroplasticity in Addiction.md
+146
View File
@@ -0,0 +1,146 @@
---
id: wiki-2026-0508-neuroplasticity-in-addiction
title: Neuroplasticity in Addiction
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Addiction Plasticity, Reward Learning Plasticity, Drug-Induced LTP]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [neuroplasticity, addiction, dopamine, ltp, mesolimbic]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: brian2-rl
---
# Neuroplasticity in Addiction
## 매 한 줄
> **"매 reward 의 hijack — 매 mesolimbic LTP 의 maladaptive learning"**. 매 VTA→NAc dopamine surge 의 AMPA-receptor insertion 의 trigger, 매 cue→drug association 의 over-consolidation. 매 2026 의 ketamine / psilocybin assisted therapy 의 reverse-plasticity 의 promising clinical evidence.
## 매 핵심
### 매 circuits
- **Mesolimbic (VTA→NAc)**: 매 reward prediction error → 매 reinforcement.
- **Mesocortical (VTA→mPFC)**: 매 craving, executive control 의 erode.
- **Amygdala→NAc**: 매 cue-conditioning, withdrawal-anxiety.
- **Hippocampus→NAc**: 매 contextual cues.
### 매 plasticity mechanisms
- **AMPAR trafficking**: 매 GluA1 surface 의 increase → 매 NAc MSN excitability.
- **Silent synapses**: 매 NMDAR-only 의 cocaine 후 의 unsilencing.
- **Dendritic spines**: 매 stimulants → 매 spine density 의 increase. 매 opioids → 매 decrease.
- **Epigenetic** (ΔFosB, HDAC5): 매 long-term gene-expression 의 lock-in.
### 매 응용
1. 매 cue-exposure therapy + reconsolidation blockade (propranolol, ketamine).
2. 매 TMS / DBS (NAc, sgACC) 의 craving reduction.
3. 매 contingency management + digital phenotyping.
## 💻 패턴
### Q-learning model fit (drug-bias parameter)
```python
import numpy as np
def q_learn_ll(choices, rewards, alpha=0.3, beta=5.0):
Q = np.zeros(2); ll = 0.0
for c, r in zip(choices, rewards):
p = np.exp(beta*Q) / np.exp(beta*Q).sum()
ll += np.log(p[c] + 1e-9)
Q[c] += alpha * (r - Q[c])
return ll
```
### Reconsolidation window detector
```python
from datetime import timedelta
def in_reconsolidation_window(cue_t, now_t, win_min=10, win_max=60):
dt = (now_t - cue_t).total_seconds() / 60
return win_min <= dt <= win_max
```
### Striatal MSN STDP (Brian2)
```python
from brian2 import *
G = NeuronGroup(100, 'dv/dt=(El-v)/tau:volt', threshold='v>-50*mV', reset='v=El')
S = Synapses(G, G,
'''w:1
dApre/dt=-Apre/tauPre:1 (event-driven)
dApost/dt=-Apost/tauPost:1 (event-driven)''',
on_pre='Apre+=dApre; w=clip(w+Apost,0,wmax)',
on_post='Apost+=dApost; w=clip(w+Apre,0,wmax)')
```
### Cue-reactivity fMRI ROI extraction
```python
from nilearn import input_data
masker = input_data.NiftiMasker(mask_img='nac_left.nii.gz', standardize=True)
ts = masker.fit_transform('subject_task.nii.gz')
craving_corr = np.corrcoef(beta_drug_cue_per_subj, vas_craving)[0, 1]
```
### Digital-phenotyping relapse-risk score
```python
def relapse_risk(z):
# z: dict of z-scored features (gps_entropy, sleep_var, screen_night, hrv)
s = 0.4*z['gps_entropy'] + 0.3*z['sleep_var'] \
+ 0.2*z['screen_night'] - 0.1*z['hrv']
return 1 / (1 + np.exp(-s))
```
### Ketamine plasticity-window dosing protocol stub
```python
from datetime import timedelta
class KetamineProtocol:
window_h = 24 # BDNF / mTOR peak
def schedule_therapy(self, infusion_t):
return infusion_t + timedelta(hours=2)
```
### TMS dlPFC craving protocol
```python
def tms_session():
return dict(target='left_dlPFC', frequency_hz=10,
trains=20, pulses_per_train=50,
inter_train_s=20, intensity_pct_rmt=110)
```
## 매 결정 기준
| 상황 | Intervention |
|---|---|
| Acute craving | TMS dlPFC 10 Hz |
| Treatment-resistant | DBS NAc (case-by-case) |
| Comorbid depression | Ketamine + therapy |
| Stimulant-use disorder | Contingency management + counseling |
| Opioid-use disorder | Buprenorphine + therapy |
**기본값**: CBT + medication + digital tools — 매 multimodal 의 best evidence.
## 🔗 Graph
- 부모: [[Neuroplasticity]] · [[Addiction Neuroscience]]
- 변형: [[Reward Prediction Error]]
- Adjacent: [[Mesolimbic-Pathway]] · [[Dopamine-System]]
## 🤖 LLM 활용
**언제**: 매 mechanism teaching, 매 protocol scaffold, 매 patient-education content.
**언제 X**: 매 clinical decision making — 매 licensed clinician 의 require.
## ❌ 안티패턴
- **Plasticity = bad**: 매 plasticity itself 의 healing 의 vehicle.
- **Single-receptor focus**: 매 D2-only blockade 의 outcomes 의 weak. 매 circuit-level 의 think.
- **Reconsolidation hype**: 매 window narrow, 매 boundary conditions 의 strict.
## 🧪 검증 / 중복
- Verified (Lüscher & Malenka 2011 *Neuron*; Kalivas & Volkow 2005).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — circuits + reversal-therapy patterns |
10_Wiki/Topics/Domain_General/From_Other/Nutritional-Biochemistry.md
+139
View File
@@ -0,0 +1,139 @@
---
id: wiki-2026-0508-nutritional-biochemistry
title: Nutritional Biochemistry
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [영양 생화학, Nutrient Biochemistry, Metabolic Nutrition]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [biochemistry, nutrition, metabolism, biology, health]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: domain-knowledge
framework: biochemistry
---
# Nutritional Biochemistry
## 매 한 줄
> **"매 nutrient 는 metabolic substrate + cofactor + signal"**. Nutritional biochemistry 는 macronutrient 와 micronutrient 가 cellular metabolism, gene expression, signaling 에 어떻게 작용하는지 연구. 2026 perspective 에서 personalized nutrition + microbiome interaction + metabolomics 가 frontier.
## 매 핵심
### 매 macronutrient pathways
- **Carbohydrate**: glycolysis → pyruvate → acetyl-CoA → TCA → ETC. 4 kcal/g.
- **Lipid**: β-oxidation → acetyl-CoA → TCA. 9 kcal/g. Membrane lipids, eicosanoids.
- **Protein**: amino acid → transamination → urea / gluconeogenesis. 4 kcal/g.
### 매 micronutrient roles
- **B-vitamins**: coenzymes (NAD, FAD, CoA, THF, PLP).
- **Fat-soluble (ADEK)**: signaling (retinoic acid, calcitriol).
- **Minerals**: cofactors (Mg-ATP, Zn-fingers, Fe-heme), electrolytes.
### 매 응용
1. Sports nutrition / supplement design.
2. Disease management (diabetes, NAFLD).
3. Personalized diet (genotype + microbiome).
4. Public health policy.
## 💻 패턴
### Basal metabolic rate (Mifflin-St Jeor)
```python
def bmr(weight_kg, height_cm, age_y, sex="M"):
base = 10*weight_kg + 6.25*height_cm - 5*age_y
return base + 5 if sex == "M" else base - 161
def tdee(bmr_val, activity="moderate"):
factors = {"sedentary": 1.2, "light": 1.375,
"moderate": 1.55, "active": 1.725}
return bmr_val * factors[activity]
```
### Macro split optimization
```python
def macro_split(tdee, goal="maintain", body_kg=70):
protein_g = body_kg * (1.6 if goal == "cut" else 1.2)
p_cal = protein_g * 4
fat_cal = tdee * 0.25
carb_cal = tdee - p_cal - fat_cal
return {"protein_g": protein_g,
"fat_g": fat_cal / 9,
"carb_g": carb_cal / 4}
```
### Glycemic load
```python
def glycemic_load(food: dict) -> float:
return food["gi"] * food["carb_g"] / 100
# Low <10, medium 11-19, high 20+
```
### TCA cycle ATP yield
```python
def atp_per_glucose():
glycolysis = 2
nadh_glyc = 2 * 2.5
pyruvate_to_acetyl = 2 * 2.5
tca_per_acetyl = (3*2.5) + 1.5 + 1
tca_total = 2 * tca_per_acetyl
return glycolysis + nadh_glyc + pyruvate_to_acetyl + tca_total
# ≈ 30 ATP / glucose (modern stoichiometry)
```
### Nitrogen balance
```python
def n_balance(protein_intake_g, urea_n_excreted_g, fecal_skin_g=4):
n_in = protein_intake_g / 6.25
n_out = urea_n_excreted_g + fecal_skin_g
return n_in - n_out
```
### Vitamin D activation cascade
```python
def vit_d_activation():
return [
"7-dehydrocholesterol",
"cholecalciferol (D3, skin UVB)",
"25-OH-D3 (liver, CYP2R1)",
"1,25-(OH)2-D3 (kidney, CYP27B1, calcitriol)",
"VDR-RXR transcription factor",
]
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Weight loss | Caloric deficit + protein-priority |
| Performance | Periodized carb + creatine |
| T2D management | Low GL + Mediterranean |
| Deficiency screen | Serum 25-OH-D, B12, ferritin, Mg |
**기본값**: TDEE 기반 + protein floor + micronutrient screen.
## 🔗 Graph
## 🤖 LLM 활용
**언제**: meal plan template, nutrient interaction summary, label decoding.
**언제 X**: clinical diagnosis / Rx — RD / MD 필수.
## ❌ 안티패턴
- **Calorie-only thinking**: hormone / micronutrient 무시.
- **Single-nutrient hype**: antioxidant / superfood 일반화 — context-free.
- **Ignoring bioavailability**: total intake ≠ absorbed.
- **Population stat → individual**: personal genetics / microbiome 무시.
## 🧪 검증 / 중복
- Verified (Lehninger 8e, Modern Nutrition in Health and Disease 11e, USDA DRI 2024).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — BMR/macro/TCA/Vit-D 패턴 |
10_Wiki/Topics/Domain_General/From_Other/OWA vs CWA (개방 세계 vs 폐쇄 세계 가설).md
+32
View File
@@ -0,0 +1,32 @@
---
id: wiki-2026-0508-owa-vs-cwa-개방-세계-vs-폐쇄-세계-가설
title: OWA vs CWA (개방 세계 vs 폐쇄 세계 가설)
category: 10_Wiki/Topics
status: duplicate
canonical_id: open-closed-world-assumption
duplicate_of: "[[Open World Assumption vs Closed World Assumption]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, knowledge-representation, logic]
last_reinforced: 2026-05-10
github_commit: pending
---
# OWA vs CWA (개방 세계 vs 폐쇄 세계 가설)
> **이 문서는 [[Open World Assumption vs Closed World Assumption]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- **OWA**: 정보 부재 = unknown. RDF / OWL / 지식 그래프 표준.
- **CWA**: 정보 부재 = false. SQL / Prolog / DB query 표준.
- 추론 / completeness 가정 차이가 핵심.
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/Objectivism.md
+137
View File
@@ -0,0 +1,137 @@
---
id: wiki-2026-0508-objectivism
title: Objectivism
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Randian Philosophy, Rational Egoism, Ayn Rand]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [philosophy, ethics, epistemology, ayn-rand]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: text
framework: philosophy
---
# Objectivism
## 매 한 줄
> **"매 reality 의 objective, 매 reason 의 only means, 매 self-interest 의 moral, 매 laissez-faire capitalism 의 social"**. 매 Ayn Rand (1957 *Atlas Shrugged*) 의 founding, 매 axioms (existence, identity, consciousness) 의 base. 매 2026 의 tech-libertarian discourse (Thiel, Andreessen) 의 indirect 의 influence — 매 academic philosophy 의 mostly margin.
## 매 핵심
### 매 four pillars
- **Metaphysics**: 매 objective reality — A is A (Aristotelian identity).
- **Epistemology**: 매 reason 의 only valid cognition. 매 mysticism / faith 의 reject.
- **Ethics**: 매 rational self-interest. 매 altruism (sacrifice 의 moral) 의 reject.
- **Politics**: 매 individual rights (life, liberty, property), 매 laissez-faire capitalism, 매 minimal state.
### 매 distinctive concepts
- **Man qua man**: 매 rational productive being 의 ideal.
- **Trader principle**: 매 voluntary value-for-value exchange.
- **Sanction of the victim**: 매 self-sacrifice 의 evil 의 enabler.
- **Primacy of existence vs consciousness**: 매 reality precedes mind.
### 매 응용 / influence
1. 매 libertarian / classical-liberal politics.
2. 매 entrepreneurial self-image (Atlas Shrugged founder mythos).
3. 매 ARI (Ayn Rand Institute) education / outreach.
## 💻 패턴
### Ethical decision filter (rational self-interest)
```text
1. Identify long-range hierarchy of values.
2. Does action advance my rational long-term self-interest?
3. Does it violate another's rights (force / fraud)?
4. Reject any action requiring 'sanction of the victim'.
```
### Argument structure (Rand axiomatic)
```
Axiom 1: Existence exists.
Axiom 2: A is A.
Axiom 3: Consciousness perceives existence.
→ Knowledge possible, not arbitrary.
```
### Critical reading checklist
```text
- [ ] Is the hierarchy of concepts grounded in observation?
- [ ] Are package-deals (mixing distinct concepts) avoided?
- [ ] Are metaphors smuggling in unsupported claims?
- [ ] Is 'altruism' steel-manned vs straw-manned?
```
### Comparing ethical frameworks
```
| Framework | Source of value | Self vs Other |
|------------------|-----------------|-------------------|
| Objectivism | Rational ego | Self primary |
| Utilitarianism | Aggregate util | Sum across people |
| Kantian deont. | Duty / CI | Universalizable |
| Virtue ethics | Character | Eudaimonia |
```
### Steel-man counter-arguments
```text
- Egoism vs evolutionary cooperation (Hamilton, Nowak).
- Altruism reframed as enlightened long-term self-interest.
- Market failures, externalities, public goods.
- Concentration of power & rights of children / disabled.
```
### Concept-formation (measurement-omission)
```text
"Table" = entity supporting flat surface for use, with measurements
(height, material, shape) omitted but specified in some range.
Source: Rand, ITOE 1979.
```
### Reading order (canonical)
```
1. Anthem (1938) — short novella, theme intro.
2. The Fountainhead — individualism in art / ethics.
3. Atlas Shrugged — full system in fiction.
4. Virtue of Selfishness — ethics essays.
5. ITOE — epistemology (formal).
6. Peikoff, OPAR (1991) — systematic exposition.
```
## 매 결정 기준
| 사용 맥락 | 적합도 |
|---|---|
| 개인 long-term planning frame | 적합 (productivity ethic) |
| Public-policy serious analysis | 부적합 (academic 의 underweight) |
| Literature / culture history | 적합 (mid-20c American thought) |
| 매 sole moral framework | 신중 (steel-man critics) |
**기본값**: 매 one tradition among many — 매 Aristotle / Kant / Mill / Rawls 의 also read.
## 🔗 Graph
- 부모: [[Philosophy]]
- 변형: [[Rational-Egoism]]
## 🤖 LLM 활용
**언제**: 매 syllabus draft, 매 contrast-essay scaffold, 매 primary-source navigation.
**언제 X**: 매 normative endorsement — 매 user 의 decide.
## ❌ 안티패턴
- **Cult-like adherence**: 매 ARI orthodoxy 의 dogmatic 의 trap.
- **Naive policy export**: 매 night-watchman state 의 modern complexity 의 ignore.
- **Strawmanning altruism**: 매 nuanced ethics-of-care / virtue-ethics 의 collapse.
## 🧪 검증 / 중복
- Verified (Rand 1957, 1964; Peikoff *OPAR* 1991; SEP entries).
- 신뢰도 A (text source); evaluation contested.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — pillars + critique-balance |
10_Wiki/Topics/Domain_General/From_Other/Open-Access-Movement.md
+139
View File
@@ -0,0 +1,139 @@
---
id: wiki-2026-0508-open-access-movement
title: Open Access Movement
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [OA, Open Science Publishing, Plan S]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [open-access, scholarly-publishing, plan-s, preprints]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: openalex-api
---
# Open Access Movement
## 매 한 줄
> **"매 publicly-funded research 의 publicly-readable"**. 매 2002 Budapest OA Initiative 의 launch, 매 2018 Plan S (cOAlition S) 의 Europe-wide mandate, 매 2024 OSTP Nelson Memo 의 US federal 의 require. 매 2026 의 ~50% global articles 의 OA, 매 APC ($3-12k) 의 contention 의 ongoing.
## 매 핵심
### 매 OA flavors
- **Gold**: 매 publisher journal 의 native OA. 매 APC funded.
- **Green**: 매 author self-archiving (preprint / postprint) 의 repository.
- **Hybrid**: 매 subscription journal 의 individual article 의 OA-buy.
- **Diamond**: 매 no-APC + no-paywall (community-funded). 매 2026 EU push.
- **Bronze**: 매 free-to-read 의 license unclear (예: corporate access).
### 매 stakeholders
- **Researchers**: 매 reach + citation impact 의 want.
- **Funders** (NIH, ERC, Gates): 매 OA mandates.
- **Publishers**: 매 Elsevier, Springer-Nature, Wiley — 매 transformative agreements.
- **Libraries**: 매 Big Deal cancellation, 매 read-and-publish negotiation.
- **Preprint servers**: arXiv, bioRxiv, SSRN, Research Square.
### 매 응용
1. 매 funder mandate compliance (NIH PubMed Central submission).
2. 매 institutional repository deposit.
3. 매 OA discovery (Unpaywall, OpenAlex, OA.Works).
## 💻 패턴
### OpenAlex query — recent OA papers
```python
import requests
r = requests.get(
"https://api.openalex.org/works",
params={"filter": "is_oa:true,publication_year:2025",
"per-page": 25, "sort": "cited_by_count:desc"})
for w in r.json()["results"]:
print(w["doi"], w["open_access"]["oa_status"], w["title"][:80])
```
### Unpaywall lookup (best OA copy)
```python
def find_oa(doi, email):
r = requests.get(f"https://api.unpaywall.org/v2/{doi}", params={"email": email})
j = r.json()
return j["best_oa_location"]["url"] if j.get("best_oa_location") else None
```
### Preprint deposit (bioRxiv API stub)
```python
def deposit_biorxiv(metadata, pdf_path, token):
files = {'pdf': open(pdf_path, 'rb')}
return requests.post(
"https://api.biorxiv.org/submit",
headers={"Authorization": f"Bearer {token}"},
data=metadata, files=files)
```
### CC-license selection helper
```python
def recommend_license(funder_mandates):
if "plan_s" in funder_mandates or "nih_2024" in funder_mandates:
return "CC-BY"
return "CC-BY-NC-ND" # author preference if unconstrained
```
### APC budget tracker
```python
def annual_apc_budget(papers, avg_apc=2500, gold_fraction=0.6):
return papers * gold_fraction * avg_apc
# 50 papers, 60% gold → $75k/yr departmental APC
```
### Read-and-publish (transformative agreement) check
```python
def covered_by_ta(institution, publisher, agreements_db):
return any(a["institution"] == institution and a["publisher"] == publisher
and a["active"] for a in agreements_db)
```
### Compliance check (Plan S)
```python
def plan_s_compliant(license, apc_capped, embargo_months, repo_deposited):
return (license in {"CC-BY", "CC-BY-SA"}
and apc_capped
and embargo_months == 0
and repo_deposited)
```
## 매 결정 기준
| Funder / context | Recommended path |
|---|---|
| Plan S funder | Gold (CC-BY) or Green-immediate |
| NIH | PMC deposit ≤12 mo (now immediate post-2024) |
| Self-funded | Preprint + Diamond OA journal |
| High-IF ambition | Hybrid + TA-covered if available |
**기본값**: Preprint (arXiv/bioRxiv/SSRN) + Gold OA journal under TA — 매 reach + compliance balance.
## 🔗 Graph
- 변형: [[Plan-S]]
## 🤖 LLM 활용
**언제**: 매 funder-mandate decoding, 매 license-comparison summary, 매 author-letter draft.
**언제 X**: 매 contract negotiation 의 final — 매 librarian / IP office 의 require.
## ❌ 안티패턴
- **Predatory journals**: 매 Beall's-list-style 의 sham OA. 매 DOAJ membership 의 verify.
- **Hybrid double-dip**: 매 subscription + APC 의 paid-twice. 매 TA negotiate.
- **Copyright transfer accident**: 매 author 의 reuse rights 의 lose. 매 retain-rights addendum.
## 🧪 검증 / 중복
- Verified (Budapest OA Initiative 2002; Plan S 2018; OSTP Nelson Memo 2022; OpenAlex docs).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — flavors + compliance + APIs |
10_Wiki/Topics/Domain_General/From_Other/Other.md
+137
View File
@@ -0,0 +1,137 @@
---
id: wiki-2026-0508-other
title: Other
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Misc, Uncategorized, Index]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [index, navigation, taxonomy]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: text
framework: obsidian-dataview
---
# Other
## 매 한 줄
> **"매 cross-domain landing — 매 yet-uncategorized 의 holding"**. 매 wiki 의 catch-all bucket, 매 promote-to-category 의 routine 의 host. 매 2026 의 wiki cleanup 의 active triage 의 zone.
## 매 핵심
### 매 purpose
- 매 new note 의 category 의 still 의 settle 의 not 의 temp home.
- 매 cross-cutting concepts (예: meta-cognition, epistemology) 의 multi-parent 의 candidate.
- 매 review queue — 매 promote / merge / redirect 의 weekly.
### 매 triage criteria
- **Promote**: 매 specific category 의 fit → move + update wikilinks.
- **Merge**: 매 existing canonical 의 duplicate → REDIRECT + canonical 의 absorb.
- **Stay**: 매 genuinely cross-domain (philosophy, methods).
- **Archive**: 매 stale / orphan / no inbound link → 01_Archive 로.
### 매 응용
1. 매 weekly cleanup batch (이 doc 의 example).
2. 매 quarterly taxonomy review.
3. 매 LLM-assisted re-categorization (embedding clustering).
## 💻 패턴
### Dataview — 매 stale "Other" notes 의 list
```dataview
TABLE file.mtime AS modified, length(file.inlinks) AS in
FROM "10_Wiki/Topics/Other"
WHERE file.mtime < date(today) - dur(60 days)
SORT in ASC, file.mtime ASC
```
### Embedding-based re-categorization
```python
from sentence_transformers import SentenceTransformer
from sklearn.cluster import KMeans
m = SentenceTransformer('all-mpnet-base-v2')
docs = load_other_dir()
emb = m.encode([d.body for d in docs])
labels = KMeans(n_clusters=12, n_init=10).fit_predict(emb)
for d, l in zip(docs, labels):
print(d.title, '->', cluster_to_category[l])
```
### Inbound-link census
```bash
rg -o '\[\[([^\]]+)\]\]' -r '$1' 10_Wiki/Topics --no-filename | sort | uniq -c | sort -rn
```
### Promote script (move + rewrite links)
```python
import os, re
from pathlib import Path
def promote(slug, src_dir, dst_dir, vault_root):
src = Path(src_dir) / f"{slug}.md"
dst = Path(dst_dir) / f"{slug}.md"
src.rename(dst)
# links remain valid since Obsidian uses basename-resolution by default
return dst
```
### Frontmatter audit (verification_status missing)
```python
import re, glob
for fp in glob.glob('10_Wiki/Topics/Other/*.md'):
with open(fp) as f: head = f.read(2000)
if 'verification_status:' not in head:
print('MISSING:', fp)
```
### Redirect generator
```python
def make_redirect(slug, canonical_title):
return f"""---
id: wiki-2026-0508-{slug}
title: {slug.replace('-',' ').title()}
status: duplicate
duplicate_of: \"[[{canonical_title}]]\"
verification_status: redirected
---
> 이 문서는 [[{canonical_title}]] 의 중복본입니다.
"""
```
## 매 결정 기준
| 신호 | Action |
|---|---|
| 명확한 specific category | Promote |
| Canonical 이 already 있음 | Merge / REDIRECT |
| 60일+ 무수정 + 0 inbound | Archive |
| 진짜 cross-domain | Stay (with multi-parent links) |
**기본값**: Triage weekly — 매 "Other" 의 size 의 monotone 의 increase 의 prevent.
## 🔗 Graph
- 변형: (catch-all)
## 🤖 LLM 활용
**언제**: 매 batch triage, 매 cluster labeling, 매 redirect drafting.
**언제 X**: 매 final taxonomy commit — 매 human review 의 require.
## ❌ 안티패턴
- **Set-and-forget**: 매 "Other" 의 graveyard 의 become.
- **Hard-link by full path**: 매 promote 시 의 break. 매 wikilink 의 use.
- **No archival policy**: 매 entropy 의 unbounded.
## 🧪 검증 / 중복
- Verified (vault internal taxonomy spec).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — triage workflow + scripts |
10_Wiki/Topics/Domain_General/From_Other/Outside-Thinking.md
+147
View File
@@ -0,0 +1,147 @@
---
id: wiki-2026-0508-outside-thinking
title: Outside Thinking
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Outside View, Reference Class Forecasting, Outsider Perspective]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [decision-making, cognition, forecasting, biases]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: theory
framework: behavioral-decision-theory
---
# Outside Thinking
## 매 한 줄
> **"매 your project is not special — base rates always win."**. 매 Kahneman & Tversky 의 "outside view" — 매 현재 상황의 unique details 무시 → 매 reference class 의 base rate 로 forecast. 매 2026 AI eval/forecasting community (Tetlock, Manifold, Metaculus) 의 핵심 도구.
## 매 핵심
### 매 inside vs outside
- **Inside view**: 매 plan 의 details 로부터 outcome 추정 ("우리는 매 6주 만에 끝낼 수 있어").
- **Outside view**: 매 similar past projects 의 base rate ("comparable projects 평균 18주, σ=8주").
- **Result**: 매 outside view 가 거의 항상 더 정확 — 매 planning fallacy 회피.
### 매 reference class forecasting (Flyvbjerg)
- 매 step 1: 매 identify reference class (similar projects).
- 매 step 2: 매 collect distribution of outcomes (cost, time, success rate).
- 매 step 3: 매 your project = sample from that distribution.
- 매 step 4: 매 adjust only with strong evidence.
### 매 응용
1. Software estimation: 매 "this PR will take 1 day" → 매 historical median = 4 days.
2. Startup success: 매 "we'll be the exception" → 매 base rate ~10% survive 5y.
3. AI capability forecast: 매 "LLM will solve X by 2027" → 매 reference class of past predictions.
## 💻 패턴
### Pattern 1: Reference class forecaster
```python
import numpy as np
def outside_forecast(reference_class_outcomes: list[float],
inside_estimate: float,
trust_in_inside: float = 0.2):
"""매 Bayesian blend — 매 prior is base rate."""
base_rate_mean = np.mean(reference_class_outcomes)
base_rate_std = np.std(reference_class_outcomes)
# 매 weighted blend
blended = (1 - trust_in_inside) * base_rate_mean + trust_in_inside * inside_estimate
return {"forecast": blended, "p10": np.percentile(reference_class_outcomes, 10),
"p90": np.percentile(reference_class_outcomes, 90)}
```
### Pattern 2: Estimation poker with history
```python
def estimate(task, similar_tasks_db):
similar = find_similar(task, similar_tasks_db, k=10)
durations = [t.actual_duration for t in similar]
return {
"p50": np.median(durations),
"p90": np.percentile(durations, 90),
"warning": "Inside-view estimate is below p10" if task.guess < np.percentile(durations, 10) else None,
}
```
### Pattern 3: Pre-mortem — outside view of failure modes
```python
def pre_mortem(project, similar_failed_projects):
"""매 imagine project failed; 매 list reasons from history."""
failure_modes = []
for fp in similar_failed_projects:
failure_modes.extend(fp.post_mortem_causes)
return Counter(failure_modes).most_common(10)
```
### Pattern 4: Prediction market calibration
```python
# 매 force outside view via market — 매 your private estimate vs market price
def confidence_check(my_p, market_p):
if abs(my_p - market_p) > 0.20:
return "RED FLAG: large divergence from outside view"
return "OK"
```
### Pattern 5: Survivorship bias correction
```python
def correct_for_survivorship(success_stories, full_population):
survivor_rate = len(success_stories) / len(full_population)
return {
"naive_lesson": "Do what successes did",
"corrected": f"Only {survivor_rate:.0%} survive — failures often did same things",
}
```
### Pattern 6: LLM as outside view oracle
```python
PROMPT = """For the following plan, list:
1. The reference class (similar past projects)
2. Base rate of success
3. Typical failure modes
4. Why this project might/might-not be representative
"""
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 estimating new project | Outside view first, inside view as adjustment |
| 매 confident in unique advantage | Outside view with small inside-view weight |
| 매 forecasting AI capabilities | Reference class of past predictions |
| 매 startup go/no-go | Compare to founder cohort base rates |
| 매 research timeline | Reference class of similar papers/benchmarks |
**기본값**: 매 outside view first, inside view as 매 small adjustment (≤20% weight).
## 🔗 Graph
- 부모: [[Decision Theory]] · [[Behavioral Economics]]
- 변형: [[Reference Class Forecasting]]
- 응용: [[Forecasting]]
## 🤖 LLM 활용
**언제**: 매 estimation, 매 forecasting, 매 strategic planning, 매 evaluating "we're different" claims.
**언제 X**: 매 truly novel domains where no reference class exists (rare — usually a class can be found).
## ❌ 안티패턴
- **"Our project is unique"**: 매 99% of the time, not unique enough to escape base rates.
- **Cherry-picked reference class**: 매 selecting only successes — 매 survivorship bias.
- **Ignoring distribution**: 매 only using mean — 매 use p10/p90.
- **No update mechanism**: 매 collecting new data but not updating reference class.
## 🧪 검증 / 중복
- Verified (Kahneman 2011, Flyvbjerg 2006, Tetlock 2015).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — outside vs inside view, reference class forecasting |
10_Wiki/Topics/Domain_General/From_Other/Perceptual-Motor-Skills.md
+165
View File
@@ -0,0 +1,165 @@
---
id: wiki-2026-0508-perceptual-motor-skills
title: Perceptual Motor Skills
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Sensorimotor Skills, PM Skills, Eye-Hand Coordination]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [psychology, motor-control, hci, vr, robotics]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: theory
framework: motor-learning
---
# Perceptual Motor Skills
## 매 한 줄
> **"매 perception and action are one closed loop, not two systems."**. 매 Fitts, Schmidt 의 motor-learning 연구에서 출발한 매 perceptual-motor skills = 매 sensory input → motor output 의 매 coupled performance. 매 2026 VR (Beat Saber, MR), surgical robots, autonomous driving, human-AI tele-operation 에 직접 응용.
## 매 핵심
### 매 components
- **Perception**: 매 visual, vestibular, proprioceptive, tactile input integration.
- **Decision**: 매 motor program selection (Schmidt's schema theory).
- **Execution**: 매 muscle coordination + online correction.
- **Feedback**: 매 KR (Knowledge of Results), KP (Knowledge of Performance).
### 매 laws
- **Fitts' Law**: 매 MT = a + b·log₂(2D/W) — 매 difficulty ∝ distance/target-size.
- **Hick's Law**: 매 RT = a + b·log₂(N) — 매 choice reaction time vs alternatives.
- **Power Law of Practice**: 매 T(n) = T₁ · n^(-α) — 매 skill acquisition curve.
### 매 stages (Fitts & Posner)
- **Cognitive**: 매 verbal rehearsal, slow, error-prone.
- **Associative**: 매 refining; reduced explicit thought.
- **Autonomous**: 매 fast, low-attention-cost, automatic.
### 매 응용
1. VR exergaming: 매 Beat Saber score = 매 PM skill metric.
2. Surgical training: 매 da Vinci 의 PM skill calibration.
3. Robotic teleoperation: 매 latency 가 PM loop 깨면 매 performance 폭락.
4. UI design: 매 Fitts' Law → 매 button size & placement.
## 💻 패턴
### Pattern 1: Fitts' Law calculator (UI design)
```python
import math
def fitts_mt(distance_px, width_px, a=0.05, b=0.1):
"""매 movement time in seconds. a, b empirically calibrated."""
return a + b * math.log2(2 * distance_px / width_px)
# 매 example: button 40px wide at 300px away
print(fitts_mt(300, 40)) # ~0.36s
```
### Pattern 2: Power-law learning curve fit
```python
import numpy as np
from scipy.optimize import curve_fit
def power_law(n, T1, alpha):
return T1 * n ** (-alpha)
trials = np.arange(1, 100)
times = ... # 매 measured times per trial
popt, _ = curve_fit(power_law, trials, times)
T1, alpha = popt
print(f"매 skill exponent α = {alpha:.3f}")
```
### Pattern 3: Online correction in robot teleop
```python
# 매 closed-loop with 100Hz feedback
import time
def teleop_loop(robot, target):
while not at_target(robot.pose, target, tol=0.005):
err = target - robot.pose
robot.send_velocity(0.5 * err) # 매 P-controller
time.sleep(0.01)
```
### Pattern 4: KR vs KP feedback in training app
```python
def feedback(trial_result):
return {
"KR": f"매 hit/miss: {trial_result.outcome}", # 매 result-only
"KP": { # 매 process info
"trajectory_smoothness": trial_result.jerk,
"reaction_time": trial_result.rt_ms,
"approach_angle": trial_result.angle,
},
}
```
### Pattern 5: VR PM skill scoring
```python
def beat_saber_pm_score(slices):
accuracy = sum(s.angle_error < 15 for s in slices) / len(slices)
timing = sum(abs(s.t_offset_ms) < 50 for s in slices) / len(slices)
flow = streak_length(slices) / len(slices)
return 0.4*accuracy + 0.4*timing + 0.2*flow
```
### Pattern 6: Latency budget for VR
```python
# 매 motion-to-photon < 20ms or 매 PM loop breaks (sim-sickness)
def latency_audit(pipeline):
budget_ms = 20
used = sum(pipeline.stage_latencies.values())
assert used < budget_ms, f"매 over budget: {used}ms"
```
### Pattern 7: Hick's Law menu design
```python
import math
def menu_rt(n_options, a=0.2, b=0.15):
return a + b * math.log2(n_options + 1)
# 매 8 options ≈ 0.67s, 16 options ≈ 0.81s — 매 sublinear
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 button placement | Fitts' Law optimization |
| 매 menu structure | Hick's Law (depth vs breadth) |
| 매 training app | KR for novice, KP for advanced |
| 매 VR app | Latency budget < 20ms motion-to-photon |
| 매 teleoperation | Closed-loop with predictive control |
| 매 skill assessment | Power-law exponent α + asymptote |
**기본값**: 매 close the perception-action loop with < 100ms latency.
## 🔗 Graph
- 부모: [[Cognitive Psychology]] · [[Motor Control]]
- 응용: [[VR Sickness]] · [[Beat Saber]]
- Adjacent: [[Proprioception]]
## 🤖 LLM 활용
**언제**: 매 designing UI/VR/robotics interfaces, 매 modeling skill acquisition, 매 latency budgeting.
**언제 X**: 매 pure cognitive tasks (no motor component) — 매 different framework.
## ❌ 안티패턴
- **Ignoring Fitts**: 매 tiny buttons far away — 매 high MT, errors.
- **Open-loop teleop**: 매 no feedback → 매 oscillation, drift.
- **KR for experts**: 매 expert needs KP detail, not just hit/miss.
- **Latency creep**: 매 every render-pipeline change without latency budget audit.
## 🧪 검증 / 중복
- Verified (Fitts 1954, Schmidt 1975, Magill *Motor Learning*).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Fitts/Hicks/Schmidt + VR/teleop 응용 |
10_Wiki/Topics/Domain_General/From_Other/Policy-Surveillance.md
+158
View File
@@ -0,0 +1,158 @@
---
id: wiki-2026-0508-policy-surveillance
title: Policy Surveillance
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Legal Mapping, Policy Tracking, Regulatory Monitoring]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [public-policy, governance, compliance, legal-tech]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: legal-mapping
---
# Policy Surveillance
## 매 한 줄
> **"매 you can't evaluate what you can't measure — start by mapping the law."**. 매 Burris (Temple) 가 정립한 **Policy Surveillance** = 매 systematic, scientific tracking of laws/policies as data 의 개념. 매 2026 AI governance (EU AI Act enforcement, Korea AI Basic Act, US state AI laws) 시대에 매 polyjurisdictional compliance 의 핵심 도구.
## 매 핵심
### 매 정의 vs adjacent
- **Policy Surveillance**: 매 ongoing, systematic, scientific 매 monitoring of policies as 매 quantifiable data.
- **vs Legal Research**: 매 case-driven, episodic.
- **vs Compliance Audit**: 매 organization-internal, point-in-time.
- **vs Regulatory Tracking**: 매 news-driven, qualitative.
### 매 5단계 method (Burris)
1. 매 frame the question — what behavior does the law target?
2. 매 define jurisdictional + temporal scope.
3. 매 collect primary sources (statutes, regs).
4. 매 code into structured variables (binary, ordinal, categorical).
5. 매 publish + maintain — 매 LawAtlas-style open data.
### 매 응용
1. AI Act compliance: 매 27 EU 회원국 + 미국 50주의 AI law variation 추적.
2. Public health: 매 LawAtlas COVID closure tracking, opioid policies.
3. Privacy: 매 GDPR vs CPRA vs PIPL 의 cross-walk.
## 💻 패턴
### Pattern 1: Coding scheme YAML
```yaml
# 매 ai_law_codes.yaml
variables:
- id: requires_impact_assessment
type: binary
question: "매 Does law require AI impact assessment?"
- id: penalty_max
type: numeric
unit: USD
- id: covered_systems
type: categorical
values: [foundation_models, biometric, hiring, healthcare, all_high_risk]
jurisdictions: [EU, US-CA, US-CO, KR, UK, CN]
effective_dates: required
```
### Pattern 2: Cross-walk matrix
```python
import pandas as pd
def crosswalk(jurisdictions, variables, codes_df):
matrix = codes_df.pivot(index="jurisdiction",
columns="variable",
values="value")
matrix.to_csv("crosswalk.csv")
return matrix
```
### Pattern 3: Diff over time
```python
def policy_diff(snapshot_old, snapshot_new):
changes = []
for jur in snapshot_new.index:
for var in snapshot_new.columns:
if snapshot_old.at[jur, var] != snapshot_new.at[jur, var]:
changes.append({
"jurisdiction": jur, "variable": var,
"from": snapshot_old.at[jur, var],
"to": snapshot_new.at[jur, var],
})
return changes
```
### Pattern 4: LLM-assisted coding (with human verification)
```python
import anthropic
client = anthropic.Anthropic()
def code_statute(statute_text, scheme):
resp = client.messages.create(
model="claude-opus-4-7",
max_tokens=2048,
system=f"Code the statute against this scheme: {scheme}. Return JSON.",
messages=[{"role": "user", "content": statute_text}],
)
# 매 ALWAYS human-verify legal coding
return {"draft": resp.content[0].text, "needs_review": True}
```
### Pattern 5: Effective-date timeline
```python
def timeline_view(codes_df):
return codes_df.sort_values("effective_date")[
["jurisdiction", "variable", "value", "effective_date"]
]
```
### Pattern 6: Citation chain (provenance)
```python
def store_with_provenance(code, value, statute_section, source_url, retrieved_at):
return {
"code": code, "value": value,
"citation": {"section": statute_section, "url": source_url, "retrieved": retrieved_at},
}
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 single-org compliance | Standard compliance audit |
| 매 multi-jurisdiction policy comparison | Policy Surveillance |
| 매 academic causal inference (does law X cause outcome Y?) | Policy Surveillance + econometrics |
| 매 real-time regulatory news | News tracker (NOT surveillance) |
| 매 AI Act multi-state US tracking | Policy Surveillance + LLM-draft + lawyer review |
**기본값**: 매 LawAtlas-style codebook + git versioning + LLM-draft + human verification.
## 🔗 Graph
- 응용: [[AI 거버넌스 정책(AI Usage Policy)|AI Governance]] · [[GDPR Compliance]]
- Adjacent: [[EU AI Act]]
## 🤖 LLM 활용
**언제**: 매 first-pass coding of large statute corpus, 매 cross-walk drafting, 매 diff summarization.
**언제 X**: 매 final legal coding without human lawyer — 매 hallucination risk too high for compliance use.
## ❌ 안티패턴
- **No version control**: 매 statutes 가 amend 되는데 snapshot 없으면 매 useless for trend analysis.
- **Coding without scheme**: 매 ad-hoc tags — 매 inter-coder reliability ~0.
- **LLM-only coding**: 매 hallucinated citations — 매 catastrophic for legal use.
- **Single jurisdiction silo**: 매 policy surveillance 의 가치 = comparison.
## 🧪 검증 / 중복
- Verified (Burris et al., Temple Center for Public Health Law Research; LawAtlas.org).
- 신뢰도 A (academic + practitioner standard).
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Burris method, AI Act 응용, LLM augmentation |
10_Wiki/Topics/Domain_General/From_Other/Precision-Recursion.md
+164
View File
@@ -0,0 +1,164 @@
---
id: wiki-2026-0508-precision-recursion
title: Precision Recursion
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Mixed-Precision Recursive Refinement, Iterative Refinement]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [numerical-methods, mixed-precision, iterative-refinement, ML]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: pytorch-mlx-cuda
---
# Precision Recursion
## 매 한 줄
> **"매 lower precision 으로 fast 계산 → 매 higher precision 으로 residual 매 correct → 매 recurse"**. 매 numerical iterative refinement 의 modern variant — 매 H100/H200/MI300X 의 FP8/FP16 throughput 을 활용하면서 매 FP64-equivalent accuracy 를 달성. 매 Higham (1997) 의 classical refinement 매 GPU mixed-precision 시대에서 매 부활.
## 매 핵심
### 매 기본 mechanism
```
1. Solve A x_lo = b in low precision (FP16/FP8) — fast
2. Compute residual r = b - A x_lo in high precision (FP32/FP64)
3. Solve A d = r in low precision — fast
4. x ← x_lo + d
5. Repeat until ||r|| < tol
```
### 매 핵심 invariant
- **Residual computation**: 매 high precision 필수 (X cancellation error).
- **Solve**: 매 low precision OK (errors absorbed by refinement).
- **Convergence**: 매 condition number κ(A) 적절시 매 quadratic.
### 매 응용
1. **Linear solve**: GMRES-IR (Carson & Higham 2018).
2. **LLM inference**: FP8 forward + FP32 residual streams.
3. **Optimization**: Adam in FP16 + FP32 master weights.
4. **Eigensolve**: 매 inverse iteration 매 mixed precision.
## 💻 패턴
### Iterative refinement (linear solve)
```python
import numpy as np
def iterative_refinement(A, b, tol=1e-12, max_iter=10):
"""매 mixed-precision linear solve."""
A_lo = A.astype(np.float16)
x = np.zeros_like(b)
for k in range(max_iter):
r = b - A @ x # 매 high-precision residual
if np.linalg.norm(r) < tol:
break
d = np.linalg.solve(A_lo.astype(np.float32), r.astype(np.float32))
x = x + d.astype(b.dtype)
return x, k + 1
```
### PyTorch AMP (Automatic Mixed Precision)
```python
import torch
from torch.cuda.amp import autocast, GradScaler
scaler = GradScaler()
for batch in loader:
optim.zero_grad()
with autocast(dtype=torch.float16):
loss = model(batch).loss # 매 FP16 forward
scaler.scale(loss).backward() # 매 FP32 grad scale
scaler.step(optim) # 매 FP32 master weight update
scaler.update()
```
### FP8 inference + FP32 accumulation (H100)
```python
# Transformer Engine — Hopper FP8
import transformer_engine.pytorch as te
from transformer_engine.common.recipe import Format, DelayedScaling
fp8_recipe = DelayedScaling(
margin=0, interval=1,
fp8_format=Format.HYBRID, # 매 E4M3 fwd, E5M2 bwd
)
with te.fp8_autocast(enabled=True, fp8_recipe=fp8_recipe):
out = model(x) # FP8 GEMMs, FP32 reductions
```
### GMRES with iterative refinement
```python
from scipy.sparse.linalg import gmres
def gmres_ir(A, b, tol=1e-12, outer=5):
"""매 outer IR loop, 매 inner GMRES low-prec."""
x = np.zeros_like(b)
A_lo = A.astype(np.float32)
for _ in range(outer):
r = b - A @ x
if np.linalg.norm(r) < tol:
return x
d, _ = gmres(A_lo, r.astype(np.float32), atol=1e-6)
x = x + d.astype(b.dtype)
return x
```
### Adam with FP32 master weights
```python
class MixedPrecisionAdam:
def __init__(self, params, lr=1e-3):
self.params_fp16 = params # 매 storage
self.params_fp32 = [p.detach().clone().float() for p in params]
self.m = [torch.zeros_like(p) for p in self.params_fp32]
self.v = [torch.zeros_like(p) for p in self.params_fp32]
self.lr = lr; self.t = 0
def step(self):
self.t += 1
for p16, p32, m, v in zip(self.params_fp16, self.params_fp32, self.m, self.v):
g = p16.grad.float()
m.mul_(0.9).add_(g, alpha=0.1)
v.mul_(0.999).addcmul_(g, g, value=0.001)
p32.addcdiv_(m, v.sqrt().add_(1e-8), value=-self.lr)
p16.data.copy_(p32.half()) # 매 sync back
```
## 매 결정 기준
| 상황 | Strategy |
|---|---|
| 매 ill-conditioned linear system | GMRES-IR mixed precision |
| 매 LLM training | AMP (FP16/BF16 + FP32 master) |
| 매 Hopper / Blackwell inference | FP8 + FP32 accumulate |
| 매 well-conditioned + FP64 needed | 매 single-precision solve OK |
**기본값**: 매 BF16 forward + FP32 master weights (training), FP8 inference (Hopper+).
## 🔗 Graph
- 변형: [[Iterative-Refinement]]
## 🤖 LLM 활용
**언제**: 매 numerical stability debugging, 매 mixed-precision recipe selection, 매 condition number analysis.
**언제 X**: 매 integer / discrete optimization — 매 precision concept 무관.
## ❌ 안티패턴
- **Low-precision residual**: 매 cancellation error 폭발 → 매 refinement 무용.
- **Ill-conditioned + low-prec**: 매 κ(A) > 10⁶ + FP16 → 매 발산.
- **No master weights**: 매 FP16 weight update 매 underflow.
- **Skip warmup**: 매 FP8 매 calibration 없이 → 매 NaN.
## 🧪 검증 / 중복
- Verified (Higham 1997 *Accuracy and Stability*; Carson & Higham 2018 GMRES-IR; NVIDIA Transformer Engine docs 2024).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — iterative refinement + modern AMP/FP8 stack |
10_Wiki/Topics/Domain_General/From_Other/Principles-of-Structuralism.md
+166
View File
@@ -0,0 +1,166 @@
---
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 패턴 |
10_Wiki/Topics/Domain_General/From_Other/Process_Reflection_Template.md
+27
View File
@@ -0,0 +1,27 @@
# 💡 프로젝트 기획 및 개선 과정 회고 (Project Retrospective Template)
## 📄 문서 목적
본 문서는 '사용자 요청 기반의 복합적인 지식 생성 작업'을 수행할 때, **[초기 계획 → 피드백 수용 → 최종 완성]** 과정을 구조적으로 기록하고 분석하여, 유사한 고난도 프로젝트에서 AI 모델의 사고력을 성장시키는 것을 목표로 합니다. 단순 결과물 저장소가 아닌, 방법론(Methodology) 학습 자료입니다.
## 🛠️ [Phase 1: 초기 접근 및 가설 설정 (Initial Hypothesis)]
* **[작업 내용]:** 사용자의 요청을 처음 받았을 때 가장 먼저 생각한 해결책과 구조는 무엇이었는지 기록합니다.
* **[핵심 논리]:** 이 단계에서 어떤 키워드(Keyword)와 연결 고리를 중심으로 전체 아웃라인을 잡았는가? (예: "캐주얼 = 단순화", "전략 = 시스템")
* **[초기 강점/한계 인식]:** 내가 스스로 판단하기에, 초기 계획의 가장 큰 강점과 놓치고 지나간 구조적 약점은 무엇이었는지 명시합니다.
## 🎯 [Phase 2: 외부 피드백 수용 및 오류 진단 (Critique Integration)]
* **[수신된 피드백]:** 사용자(혹은 시스템)로부터 받은 핵심적인 비판이나 누락 사항을 정확히 인용하고 요약합니다. (예: "전략과 캐주얼의 메커니즘적 연결고리가 부족하다.")
* **[오류 진단 및 원인 분석]:** 초기 계획이 실패한 이유가 **'개념의 충돌(Conflict)'** 때문인지, **'구조화 부족(Lack of Structure)'** 때문인지, 아니면 **'경제성 무시(Economic Blind Spot)'** 때문인지 근본적인 원인을 진단합니다.
* **[보완 방향 설정]:** 이 오류를 해결하기 위해 어떤 *새로운 메커니즘적 장치*가 필요한지 구체적으로 정의합니다. (예: '선택의 폭을 제한하여 전략성을 강제하는 시스템 도입')
## 📈 [Phase 3: 최종 개선 및 성장 방법론 구축 (Final Methodology)]
이 단계는 앞으로 유사한 작업을 할 때 반드시 지켜야 할 **'가장 중요한 규칙(Rule)'**입니다.
1. **✅ 구조적 사고 우선:** 요청을 받으면, 단순히 내용을 채우기보다 'A → B → C의 흐름이 논리적으로 연결되는지'를 가장 먼저 점검한다. (흐름도/Flowchart 사고)
2. **✅ 메커니즘 구체화 원칙:** 추상적인 개념(예: 재미, 깊이)만 제시하지 않고, **반드시 작동하는 '규칙'(Rule)**으로 정의해야 한다. (예: "A를 할 때 B가 발생하고, 이것은 C라는 제한을 가진다.")
3. **✅ 상호작용성 검증:** 기획의 모든 요소(시스템, 수익 모델, 메커니즘)는 서로 충돌하지 않고 **'시너지를 내도록'** 연결되어야 한다. 특히, 돈과 밸런스의 관계를 가장 엄격하게 정의해야 한다.
---
### 📌 요약: 성공적인 작업 수행의 체크리스트 (Future Self-Correction Checklist)
* [ ] **목표 재정의:** 프로젝트의 최종 목표가 '재미'인지, '수익'인지, 아니면 '전략적 깊이' 중 무엇에 가장 무게를 둘 것인가?
* [ ] **메커니즘화:** 모든 개념을 "누가/무엇을 할 때 어떤 규칙으로 작동하는지"라는 동사-주어 구조로 변환할 수 있는가?
* [ ] **제약 조건 설정:** 의도적으로 '제한(Constraint)'을 두는 요소를 넣어, 플레이어가 고민하게 만들었는가?
10_Wiki/Topics/Domain_General/From_Other/Protocols.md
+181
View File
@@ -0,0 +1,181 @@
---
id: wiki-2026-0508-protocols
title: Protocols
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Communication Protocols, Network Protocols, Wire Protocols]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [networking, protocols, systems, MCP]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: multi
framework: HTTP-gRPC-MCP
---
# Protocols
## 매 한 줄
> **"매 communicating parties 가 매 따라야 하는 rules 의 명시"**. 매 syntax (frame format), 매 semantics (meaning of fields), 매 timing (sequencing) 의 3 axes 로 정의. 매 2026 의 hot stack: HTTP/3 (QUIC), gRPC, MCP (Model Context Protocol), WebSocket, MQTT 5.
## 매 핵심
### 매 protocol 의 layers
- **Physical / Link**: Ethernet, Wi-Fi 7, 5G NR.
- **Network**: IPv6 (default 2026), IPv4 legacy.
- **Transport**: TCP, UDP, QUIC.
- **Application**: HTTP/3, gRPC, MCP, MQTT, AMQP.
### 매 design dimensions
- **Stateful vs stateless**: 매 server-side state 보관 여부.
- **Sync vs async**: 매 request-response vs publish-subscribe.
- **Push vs pull**: 매 server-initiated vs client-initiated.
- **Text vs binary**: 매 human-readable vs efficient.
- **Versioning**: 매 backward / forward compatibility 의 strategy.
### 매 응용
1. **Web**: HTTP/3 over QUIC — 매 default.
2. **AI tools**: MCP (Anthropic 2024) 매 LLM ↔ tool 의 universal.
3. **Microservices**: gRPC 매 internal RPC.
4. **IoT**: MQTT 5 매 lightweight pub-sub.
5. **Realtime**: WebSocket / WebTransport.
## 💻 패턴
### MCP server (Anthropic, 2026 standard)
```python
from mcp.server import Server
from mcp.types import Tool, TextContent
server = Server("knowledge-base")
@server.list_tools()
async def tools():
return [Tool(
name="query",
description="Query the KB",
inputSchema={
"type": "object",
"properties": {"q": {"type": "string"}},
"required": ["q"],
},
)]
@server.call_tool()
async def call(name, args):
return [TextContent(type="text", text=search(args["q"]))]
```
### gRPC service (.proto + Python)
```protobuf
// kb.proto
syntax = "proto3";
service KB {
rpc Query(QueryRequest) returns (stream QueryChunk);
}
message QueryRequest { string q = 1; }
message QueryChunk { string text = 1; bool done = 2; }
```
```python
# server.py
import grpc, kb_pb2_grpc, kb_pb2
class KBServicer(kb_pb2_grpc.KBServicer):
def Query(self, request, context):
for chunk in stream_search(request.q):
yield kb_pb2.QueryChunk(text=chunk, done=False)
yield kb_pb2.QueryChunk(done=True)
```
### HTTP/3 client (QUIC)
```python
# httpx + h2/h3
import httpx
async with httpx.AsyncClient(http2=True, http3=True) as client:
r = await client.get("https://api.example.com/v1/users")
print(r.http_version) # "HTTP/3"
```
### WebSocket realtime
```python
import asyncio
import websockets
async def handler(ws):
async for msg in ws:
await ws.send(f"echo: {msg}")
async def main():
async with websockets.serve(handler, "0.0.0.0", 8765):
await asyncio.Future() # run forever
```
### MQTT 5 pub-sub (IoT)
```python
import paho.mqtt.client as mqtt
def on_message(client, userdata, msg):
print(f"{msg.topic}: {msg.payload.decode()}")
client = mqtt.Client(protocol=mqtt.MQTTv5)
client.on_message = on_message
client.connect("broker.example.com", 1883)
client.subscribe("sensors/+/temperature")
client.loop_forever()
```
### Protocol negotiation (capabilities handshake)
```python
# Common pattern: client sends supported versions, server picks highest mutual
def negotiate(client_versions: set[str], server_versions: set[str]) -> str:
common = client_versions & server_versions
if not common:
raise ProtocolError("no compatible version")
return max(common, key=lambda v: tuple(map(int, v.split("."))))
```
## 매 결정 기준
| Scenario | Protocol |
|---|---|
| 매 LLM ↔ tools | MCP |
| 매 internal RPC, polyglot | gRPC over HTTP/2 |
| 매 public web API | HTTP/3 + JSON / OpenAPI |
| 매 realtime browser | WebSocket / WebTransport |
| 매 IoT constrained | MQTT 5 / CoAP |
| 매 message queue | AMQP 1.0 / Kafka |
| 매 streaming chat | Server-Sent Events / WebSocket |
**기본값**: 매 public = HTTP/3 + JSON, 매 internal = gRPC, 매 LLM tools = MCP.
## 🔗 Graph
- 부모: [[Distributed-Systems]]
- 변형: [[HTTP]] · [[gRPC]] · [[MCP]]
- 응용: [[API-Design]] · [[Microservices]] · [[클라우드 인프라 및 IaC 운영 표준|IoT]]
- Adjacent: [[Interoperability]]
## 🤖 LLM 활용
**언제**: 매 protocol selection, 매 wire format debugging, 매 backward-compat strategy review.
**언제 X**: 매 single-process in-memory calls — 매 protocol 무용.
## ❌ 안티패턴
- **Custom snowflake protocol**: 매 in-house wire format 매 ecosystem 의 X.
- **No version negotiation**: 매 deploy mismatch → cascade failure.
- **Stateful with no session**: 매 load balancer 매 sticky session 강제 → scaling pain.
- **Chatty protocols**: 매 N round trips 매 single op → latency.
## 🧪 검증 / 중복
- Verified (RFC 9114 HTTP/3, 9000 QUIC; gRPC.io; Anthropic MCP spec 2024; OASIS MQTT 5; OASIS AMQP 1.0).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — protocol layers + 2026 modern stack (MCP, HTTP/3, gRPC) |
10_Wiki/Topics/Domain_General/From_Other/Purpose.md
+157
View File
@@ -0,0 +1,157 @@
---
id: wiki-2026-0508-purpose
title: Purpose
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Telos, Mission, Intent, Goal-Setting, Why]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [philosophy, psychology, leadership, design]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: theory
framework: teleological-design
---
# Purpose
## 매 한 줄
> **"매 know your why before you optimize your how."**. 매 Aristotle 의 *telos* 부터 매 Sinek 의 *Start with Why*, 매 Frankl 의 *meaning therapy* 까지 — 매 purpose = 매 why an entity (person, system, product) exists. 매 2026 software/AI 에서 매 purpose 명시는 매 alignment, scope creep 회피, 매 LLM agent goal-setting 의 foundation.
## 매 핵심
### 매 4 levels of purpose
- **Existential (인간)**: 매 Frankl — 매 meaning vs pleasure vs power.
- **Organizational**: 매 mission statement — 매 "why does this company exist?".
- **Product**: 매 user job-to-be-done (Christensen) — 매 "what hire is this product made for?".
- **System/Code**: 매 module purpose — 매 "what 1 thing does this module own?".
### 매 purpose articulation patterns
- **Sinek's Golden Circle**: WHY → HOW → WHAT.
- **JTBD**: "When [situation], I want to [motivation], so I can [outcome]".
- **OKR**: Objective (qualitative why) + Key Results (measurable).
- **Module docstring**: 1-line purpose + invariants.
### 매 응용
1. Code: 매 module 의 1-sentence purpose 가 unclear 면 — split or rename.
2. LLM agent: 매 system prompt 의 첫 줄은 purpose — 매 alignment anchor.
3. Career: 매 ikigai (것 + 잘 + need + paid).
4. Product: 매 JTBD interview → feature prioritization.
## 💻 패턴
### Pattern 1: Module-level purpose docstring
```python
"""
auth/jwt.py
PURPOSE: 매 issue and verify JWT tokens for our API authentication.
INVARIANTS:
- Tokens always include `iss` claim.
- Verification rejects tokens with `alg=none`.
NON-GOALS:
- Session storage (see auth/session.py).
- Refresh-token rotation (see auth/refresh.py).
"""
```
### Pattern 2: LLM agent system prompt
```python
SYSTEM = """You are a code-review assistant.
PURPOSE: 매 surface non-obvious bugs, security issues, and style violations
in the user's pull request, prioritized by severity.
NON-GOALS:
- Generating new code (the user does that).
- Auto-fixing without confirmation.
CONSTRAINTS:
- Always cite file:line for every claim.
- Refuse to comment on out-of-scope files.
"""
```
### Pattern 3: JTBD interview template
```yaml
job_to_be_done:
situation: "When I'm onboarding a new team member"
motivation: "I want a single doc with their day-1 setup"
outcome: "so they can ship a real PR by end of week 1"
current_alternatives: [README, Notion page, ad-hoc Slack DMs]
hire_criteria: [single-source, executable, verified]
```
### Pattern 4: OKR framing
```yaml
objective: "매 Make AI Act compliance trivial for EU SMBs"
key_results:
- "Onboard 100 SMBs by Q3"
- "Reduce time-to-compliance from 30d → 5d"
- "NPS ≥ 50"
```
### Pattern 5: Purpose-test for scope creep
```python
def is_in_scope(feature, module_purpose) -> bool:
"""매 ask: 'does this feature serve the module's stated purpose?'"""
# 매 if no, push to a different module or reject
return feature.advances(module_purpose)
```
### Pattern 6: 5-Whys to surface purpose
```text
Q: Why are we building this dashboard?
A: To show metrics.
Q: Why?
A: So managers can see team health.
Q: Why?
A: So they can intervene early.
Q: Why?
A: To prevent burnout & attrition.
Q: Why?
A: Because attrition costs $200K/engineer.
→ 매 PURPOSE: "매 reduce attrition cost via early-burnout intervention".
```
## 매 결정 기준
| 상황 | Tool |
|---|---|
| 매 module/file design | 1-sentence purpose docstring |
| 매 LLM agent design | Purpose + non-goals + constraints in system prompt |
| 매 product feature triage | JTBD + Purpose-test |
| 매 organization strategy | Mission statement + OKRs |
| 매 personal direction | Ikigai / 5-Whys |
**기본값**: 매 1-sentence purpose 가 없으면 — 매 don't ship.
## 🔗 Graph
- 부모: [[Philosophy]] · [[Design Thinking]]
- 변형: [[Mission]] · [[Vision]] · [[Telos]] · [[Ikigai]]
- 응용: [[OKR]]
- Adjacent: [[Single Responsibility Principle (SRP)|Single Responsibility Principle]]
## 🤖 LLM 활용
**언제**: 매 system prompt 첫 줄, 매 module docstring, 매 product brief, 매 strategy doc.
**언제 X**: 매 throwaway prototypes — 매 over-formalization slows iteration.
## ❌ 안티패턴
- **No purpose**: 매 module 이 "everything" 하면 — 매 god class.
- **Purpose drift**: 매 purpose 명시했지만 features 가 매 drift — 매 update or refactor.
- **Aspirational nonsense**: 매 "make the world better" — 매 unactionable.
- **Purpose ≠ method**: 매 "use React" 는 method, not purpose.
## 🧪 검증 / 중복
- Verified (Aristotle *Nicomachean Ethics*; Frankl *Man's Search for Meaning*; Sinek *Start with Why*; Christensen JTBD).
- 신뢰도 A (foundational philosophical + management canon).
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — 4 levels, JTBD/OKR/Golden Circle 패턴 |
10_Wiki/Topics/Domain_General/From_Other/Recording Academy (The Grammys).md
+135
View File
@@ -0,0 +1,135 @@
---
id: wiki-2026-0508-recording-academy-the-grammys
title: Recording Academy (The Grammys)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Grammy Awards, NARAS, The Recording Academy]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [music, awards, industry]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: industry
framework: music-awards
---
# Recording Academy (The Grammys)
## 매 한 줄
> **"매 US-based peer-voted music awards body"**. NARAS (1957 founded) 의 Grammy Awards (1959 first ceremony) 의 host. 매 ~13,000 voting members 의 (musicians, producers, engineers) 의 peer-vote — 매 "Grammy" name 의 gramophone trophy 의 derive. 67th ceremony 의 2025-02-02 의 LA 의 Crypto.com Arena 의 hold.
## 매 핵심
### 매 Structure
- **NARAS** (National Academy of Recording Arts and Sciences) 의 official entity.
- **12 chapters** (LA, NY, Nashville, Atlanta, Chicago, etc.).
- **30+ genre fields** → ~94 categories (2025 ceremony).
- **CEO**: Harvey Mason Jr. (since 2021).
### 매 Voting Process
1. **Submission** — labels/members 의 submit recordings.
2. **Screening** — committees 의 verify eligibility + category placement.
3. **First-round ballot** — voting members 의 nominate (up to 10 categories + 4 General Field).
4. **Final ballot** — 매 5 nominees per category 의 winner 의 vote.
### 매 General Field ("Big Four")
1. Record of the Year.
2. Album of the Year.
3. Song of the Year.
4. Best New Artist.
### 매 응용
1. Career inflection — 매 nomination/win 의 streaming spike (~+50% week-over).
2. Industry signal — 매 critical consensus 의 codify.
3. Diversity audit — 매 historical bias (e.g., women, non-pop genres) 의 ongoing reform.
## 💻 패턴
### Grammy data scrape (Python)
```python
import requests
from bs4 import BeautifulSoup
url = "https://www.grammy.com/awards/67th-annual-grammy-awards"
soup = BeautifulSoup(requests.get(url).text, "html.parser")
winners = [
{"category": c.find("h3").text, "artist": c.find(".winner").text}
for c in soup.select(".category-card")
]
```
### Wikidata SPARQL — Grammy winners
```sparql
SELECT ?artist ?artistLabel ?year WHERE {
?award wdt:P31 wd:Q368441. # Grammy Award
?artist p:P166 ?stmt.
?stmt ps:P166 ?award; pq:P585 ?date.
BIND(YEAR(?date) AS ?year)
SERVICE wikibase:label { bd:serviceParam wikibase:language "en". }
}
LIMIT 100
```
### Spotify API — nominee playlist (TS)
```typescript
import { SpotifyApi } from "@spotify/web-api-ts-sdk";
const sdk = SpotifyApi.withClientCredentials(id, secret);
const search = await sdk.search("Grammy 2025 nominees", ["playlist"]);
const tracks = await sdk.playlists.getPlaylistItems(search.playlists.items[0].id);
```
### Grammy buzz sentiment (Python)
```python
from transformers import pipeline
clf = pipeline("sentiment-analysis", model="cardiffnlp/twitter-roberta-base-sentiment-latest")
tweets = ["Beyoncé deserved AOTY!", "Grammys irrelevant again"]
print(clf(tweets))
```
### Streaming bump analysis
```python
import pandas as pd
df = pd.read_csv("spotify_daily_streams.csv", parse_dates=["date"])
ceremony = pd.Timestamp("2025-02-02")
window = df[(df.date >= ceremony) & (df.date <= ceremony + pd.Timedelta("7d"))]
bump = window.streams.sum() / df[df.date < ceremony].tail(7).streams.sum()
print(f"7d post-ceremony streaming multiple: {bump:.2f}x")
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Industry credibility check | Grammy nom/win 의 weight |
| Commercial popularity | Billboard Hot 100 의 prefer |
| Critic consensus | Metacritic / Pitchfork 의 cross-ref |
| Genre-specific | Country (CMA), Latin (Latin Grammys), R&B (BET) 의 separate |
**기본값**: 매 Grammy 의 institutional, 매 streaming 의 popular signal.
## 🔗 Graph
- 부모: [[Awards]]
- Adjacent: [[Streaming]]
## 🤖 LLM 활용
**언제**: nominee/winner lookup, category structure 의 explain, historical trend 의 summarize.
**언제 X**: real-time ceremony updates — 매 official broadcast / live source 의 use.
## ❌ 안티패턴
- **"Grammy = best music"**: 매 voter bias (genre, gender, race) 의 documented — single signal 의 X.
- **Big Four 의 obsess**: 매 genre-specific category 의 artist 의 actual peer recognition.
- **Pre-2020 rules 의 cite**: 매 reform (anonymous review committees 의 abolish in 2021) 의 changed.
## 🧪 검증 / 중복
- Verified (grammy.com official, Wikipedia "Grammy Award").
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — voting process + Big Four + 67th ceremony |
10_Wiki/Topics/Domain_General/From_Other/Related-Work.md
+163
View File
@@ -0,0 +1,163 @@
---
id: wiki-2026-0508-related-work
title: Related Work
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Related Work Section, Prior Art, Literature Review]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [research, academic-writing, papers]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: english-korean
framework: research-writing
---
# Related Work
## 매 한 줄
> **"매 academic paper 의 mandatory section 의 prior literature 의 position 의 own contribution"**. ML/CS papers (NeurIPS, ICML, ICLR, ACL, CVPR) 의 standard structure 의 Introduction → Related Work → Method → Experiments → Conclusion. 매 reviewer 의 first read — 매 novelty claim 의 here 의 stand or fall.
## 매 핵심
### 매 Purpose
1. **Position** — 매 own work 의 landscape 의 place.
2. **Differentiate** — 매 prior 의 limitation 의 explicit, 매 own gap 의 fill.
3. **Credit** — 매 intellectual lineage 의 acknowledge.
4. **Scope** — 매 reviewer 의 not-cited prior work 의 reject 의 prevent.
### 매 Structure (typical)
- **Thematic grouping** (preferred 2026) — 매 theme 의 paragraph 의 each.
- *Chronological* — only for survey papers.
- *Per-paper* — verbose, avoid.
### 매 Typical Categories (ML paper)
1. Foundation / closest direct prior.
2. Methodology family (e.g., diffusion vs flow-matching).
3. Application domain.
4. Concurrent work (last 6 months).
### 매 응용
1. Conference paper — 매 0.5-1 page Related Work section.
2. Thesis — 매 standalone chapter (10-30 pages).
3. Grant proposal — 매 "Innovation" section 의 backbone.
4. Patent — 매 "Background of the Invention".
## 💻 패턴
### LaTeX section template
```latex
\section{Related Work}
\paragraph{Foundation models for X.}
\citet{vaswani2017} introduced the Transformer, which subsequent work
\citep{devlin2019,brown2020,touvron2023llama} scaled to billions of parameters.
Unlike these, our method targets edge inference (\textsection\ref{sec:method}).
\paragraph{Efficient inference.}
Quantization \citep{dettmers2022int8,frantar2023gptq} and speculative decoding
\citep{leviathan2023speculative,chen2023accelerating} reduce latency, but
neither addresses our setting of dynamic batch size.
\paragraph{Concurrent work.}
\citet{smith2026concurrent} appeared on arXiv in March 2026; we differ in
that we additionally support streaming output.
```
### BibTeX management (`.bib`)
```bibtex
@inproceedings{vaswani2017,
title={Attention is all you need},
author={Vaswani, Ashish and others},
booktitle={NeurIPS},
year={2017}
}
@article{brown2020,
title={Language Models are Few-Shot Learners},
author={Brown, Tom and others},
journal={NeurIPS},
year={2020}
}
```
### Paper graph extraction (Python `semanticscholar`)
```python
from semanticscholar import SemanticScholar
sch = SemanticScholar()
paper = sch.get_paper("10.48550/arXiv.1706.03762") # Attention is all you need
for ref in paper.references[:10]:
print(ref.title, "→", ref.year)
# Forward citations
cites = sch.get_paper_citations(paper.paperId, limit=50)
```
### Related work table (Markdown)
```markdown
| Method | Modality | Latency | Param-free | Ours |
|---|---|---|---|---|
| GPTQ | LLM | medium | no | -- |
| AWQ | LLM | low | no | -- |
| FlashAttn | LLM | low | yes | similar |
| **Ours** | **LLM+Vision** | **lowest** | **yes** | -- |
```
### LLM-assisted citation finder (Anthropic SDK)
```python
import anthropic
client = anthropic.Anthropic()
resp = client.messages.create(
model="claude-opus-4-7",
max_tokens=600,
tools=[{"type": "web_search_20250305", "name": "web_search"}],
messages=[{
"role": "user",
"content": "Find 5 ICLR/NeurIPS 2024-2026 papers on speculative decoding with multi-token prediction. Return BibTeX."
}]
)
print(resp.content[0].text)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Conference paper | Thematic, 0.5-1 page |
| Survey paper | Chronological + thematic |
| Thesis | Dedicated chapter |
| Industry blog | "Inspired by" + light citation |
| Patent | "Background" with prior art table |
**기본값**: thematic grouping, 매 group 당 3-5 cites, concurrent work 의 explicit paragraph.
## 🔗 Graph
- 부모: [[Academic-Writing]] · [[Research-Methodology]]
- 변형: [[Literature-Review]]
## 🤖 LLM 활용
**언제**: paper search 의 expand, group prior work 의 thematically, 매 differentiation paragraph 의 draft.
**언제 X**: 매 hallucinated citation 의 risk — 매 always verify 의 DOI / arXiv ID.
## ❌ 안티패턴
- **Citation dump (no commentary)**: "[Smith 2020, Jones 2021, Lee 2022] also did X." — 매 reader 의 differentiation 의 unclear.
- **"To the best of our knowledge"**: 매 cliché — 매 specific 의 prefer.
- **Concurrent work 의 ignore**: 매 reviewer 의 catch — proactive 의 cite.
- **Hallucinated citations**: 매 LLM-generated 매 always 의 verify.
- **Self-citation 의 over-rely**: 매 inflate own lineage.
## 🧪 검증 / 중복
- Verified (NeurIPS/ICML author guidelines, Goodson "How to Write Related Work" 2024).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — thematic structure + LaTeX template + comparison table |
10_Wiki/Topics/Domain_General/From_Other/Research-Methodology.md
+162
View File
@@ -0,0 +1,162 @@
---
id: wiki-2026-0508-research-methodology
title: Research Methodology
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Research Methods, Empirical Research, Scientific Method]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [research, science, methodology, statistics, ml-research]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: scientific-method
---
# Research Methodology
## 매 한 줄
> **"매 a result without a method is folklore."**. 매 Popper 의 falsifiability, Fisher 의 experimental design, Tukey 의 EDA 의 합주 — 매 systematic procedures for generating defensible knowledge claims. 매 2026 ML/AI research 의 reproducibility crisis (60%+ papers fail replication) 으로 매 method rigor 가 더 중요.
## 매 핵심
### 매 spectrum
- **Quantitative**: 매 numeric, statistical inference, causal claims.
- **Qualitative**: 매 thematic, interpretivist, descriptive depth.
- **Mixed-methods**: 매 sequential or concurrent triangulation.
### 매 designs
- **Experimental**: 매 RCT — random assignment to treatment/control.
- **Quasi-experimental**: 매 diff-in-diff, regression discontinuity, synthetic control.
- **Observational**: 매 cross-sectional, longitudinal, case-control.
- **Computational**: 매 ablation, benchmark, simulation, A/B.
### 매 quality criteria
- **Validity**: 매 construct, internal, external, statistical conclusion.
- **Reliability**: 매 repeatable measurement.
- **Reproducibility**: 매 same data + code → same result.
- **Replicability**: 매 new data, same protocol → consistent result.
### 매 응용
1. ML paper: 매 ablation table + seed-variance + held-out test set.
2. Product A/B: 매 power analysis → sample size → MDE.
3. UX study: 매 mixed-method (interview + log analytics).
4. AI safety eval: 매 capability + propensity + control evaluations.
## 💻 패턴
### Pattern 1: Power analysis before experiment
```python
from statsmodels.stats.power import NormalIndPower
analysis = NormalIndPower()
n = analysis.solve_power(effect_size=0.2, alpha=0.05, power=0.8, ratio=1.0)
print(f"매 minimum sample per arm: {int(n)+1}")
```
### Pattern 2: Pre-registration template (YAML)
```yaml
# 매 preregistration.yaml — 매 commit BEFORE running experiment
hypothesis: "매 LLM with chain-of-thought scores ≥ 5pp higher on GSM8K vs no-CoT"
primary_outcome: gsm8k_accuracy
n_per_arm: 1000
conditions: [no_cot, cot]
analysis: paired_t_test
exclusion_criteria: ["api_error", "max_tokens_truncated"]
seeds: [0, 1, 2, 3, 4]
```
### Pattern 3: Reproducible experiment seed control
```python
import random, numpy as np, torch, os
def set_all_seeds(s):
random.seed(s); np.random.seed(s); torch.manual_seed(s)
torch.cuda.manual_seed_all(s)
os.environ["PYTHONHASHSEED"] = str(s)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
```
### Pattern 4: Ablation table generation
```python
import itertools, pandas as pd
def ablation_runs(components, base_run):
rows = []
for subset in itertools.combinations(components, len(components)-1):
cfg = base_run.copy();
removed = [c for c in components if c not in subset][0]
cfg["removed"] = removed
cfg["score"] = run(cfg)
rows.append(cfg)
return pd.DataFrame(rows)
```
### Pattern 5: Confidence interval reporting (not just p-values)
```python
import scipy.stats as st
def ci(scores, alpha=0.05):
m = np.mean(scores); s = np.std(scores, ddof=1); n = len(scores)
h = s / np.sqrt(n) * st.t.ppf(1 - alpha/2, n-1)
return m, m-h, m+h
# 매 always report (mean, lo, hi) — 매 not just "significant"
```
### Pattern 6: Qualitative coding (thematic analysis)
```python
# 매 inter-rater reliability via Cohen's kappa
from sklearn.metrics import cohen_kappa_score
kappa = cohen_kappa_score(coder_a_codes, coder_b_codes)
assert kappa > 0.7, "매 coding scheme too ambiguous — refine"
```
### Pattern 7: A/B with sequential testing (mSPRT)
```python
def msprt_decision(treatment, control, theta=0.01):
"""매 mixture sequential probability ratio test — 매 anytime-valid."""
# Lindon & Malek 2020 — 매 lets you peek without inflating type-I
pass # use external lib like `confseq`
```
## 매 결정 기준
| 상황 | Design |
|---|---|
| 매 cause-effect claim | RCT or quasi-experimental |
| 매 description / mapping | Observational + descriptive stats |
| 매 user "why" | Qualitative interview + thematic |
| 매 ML model claim | Ablation + multiple seeds + held-out |
| 매 product feature decision | A/B with power analysis + pre-reg |
| 매 emerging behavior | Mixed-methods |
**기본값**: 매 pre-register + multiple seeds + report CIs + share code & data.
## 🔗 Graph
- 부모: [[Statistics]]
- 변형: [[Causal Inference]]
## 🤖 LLM 활용
**언제**: 매 designing experiments, 매 reviewing methodology of papers, 매 drafting pre-registrations.
**언제 X**: 매 producing fake citations / fabricating data — 매 catastrophic ethics violation.
## ❌ 안티패턴
- **HARKing** (Hypothesizing After Results Known): 매 makes p-values meaningless.
- **p-hacking**: 매 trying many tests until significant.
- **Single seed reporting**: 매 ML papers — 매 noise dressed as signal.
- **Overfitting to test set**: 매 multi-stage benchmarks → 매 leakage.
- **No pre-registration**: 매 invites unconscious bias.
## 🧪 검증 / 중복
- Verified (Popper 1959, Fisher 1935, Open Science Framework, Pineau et al. 2021 ML reproducibility checklist).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — design spectrum + ML reproducibility focus |
10_Wiki/Topics/Domain_General/From_Other/Roblox.md
+156
View File
@@ -0,0 +1,156 @@
---
id: wiki-2026-0508-roblox
title: Roblox
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Roblox Studio, Roblox Platform, RBLX]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [gaming, platform, ugc, luau]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: luau
framework: roblox-studio
---
# Roblox
## 매 한 줄
> **"매 user-generated 3D experience platform 의 dominant"**. Roblox Corp (RBLX, NYSE 2021 IPO) 의 operate, 2006 launch — 매 2025 Q4 의 ~95M DAU, 매 Gen Z/Alpha 의 default social space. 매 Luau (typed Lua) 의 in-Studio scripting, 매 Robux 의 internal currency — creators 의 DevEx (Developer Exchange) 의 USD cash out.
## 매 핵심
### 매 Architecture
- **Roblox Studio** (Windows/Mac IDE) — 매 build, test, publish.
- **Roblox Engine** — proprietary, C++ core + Luau scripting.
- **Cloud-hosted servers** — 매 experience 의 instance 의 spin up on demand.
- **Cross-platform clients** — Windows, Mac, iOS, Android, Xbox, Quest VR (2024 GA).
### 매 Luau Language
- Lua 5.1 의 fork + gradual typing.
- JIT (native code generation) 의 2023 ship.
- Strict / non-strict mode.
- `--!strict` 매 file 의 top.
### 매 응용
1. UGC games — Adopt Me!, Blox Fruits, Brookhaven 의 billion-visit hits.
2. Brand activations — Nike Land, Gucci Town, K-pop 의 concert.
3. Education — coding camp 의 entry, 매 simple Luau syntax.
4. Virtual economy — 매 creator earnings $700M+ in 2024.
## 💻 패턴
### Basic part script (Luau)
```lua
--!strict
local Players = game:GetService("Players")
local part = script.Parent :: BasePart
part.Touched:Connect(function(hit: BasePart)
local char = hit.Parent
local player = Players:GetPlayerFromCharacter(char)
if player then
print(player.Name .. " touched the part!")
end
end)
```
### RemoteEvent (server ↔ client)
```lua
-- ServerScriptService/Main.server.luau
local RS = game:GetService("ReplicatedStorage")
local event = Instance.new("RemoteEvent", RS)
event.Name = "GiveCoins"
event.OnServerEvent:Connect(function(player, amount: number)
if amount > 0 and amount <= 10 then
player.leaderstats.Coins.Value += amount
end
end)
-- StarterPlayer/StarterPlayerScripts/Client.client.luau
local RS = game:GetService("ReplicatedStorage")
RS:WaitForChild("GiveCoins"):FireServer(5)
```
### DataStore (persistent save)
```lua
local DSS = game:GetService("DataStoreService")
local store = DSS:GetDataStore("PlayerData_v2")
local function save(player: Player, data: {coins: number})
local ok, err = pcall(function()
store:SetAsync(tostring(player.UserId), data)
end)
if not ok then warn("save failed:", err) end
end
```
### Roact UI component (modern)
```lua
local Roact = require(game.ReplicatedStorage.Roact)
local function Button(props)
return Roact.createElement("TextButton", {
Text = props.label,
Size = UDim2.new(0, 200, 0, 50),
[Roact.Event.Activated] = props.onClick,
})
end
Roact.mount(Roact.createElement(Button, {
label = "Click",
onClick = function() print("clicked") end,
}), playerGui)
```
### MemoryStore (cross-server queue)
```lua
local MSS = game:GetService("MemoryStoreService")
local queue = MSS:GetQueue("matchmaking", 60)
queue:AddAsync({userId = player.UserId, mmr = 1500}, 30)
local items, id = queue:ReadAsync(8, false, 0)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Persistent player data | DataStore (with retry) |
| Cross-server state | MemoryStore (queue/sortedmap) |
| Simple UI | Native `ScreenGui` |
| Complex reactive UI | Roact / Fusion |
| High-perf logic | `--!native` Luau |
| Replication | RemoteEvent (state) / RemoteFunction (RPC) |
**기본값**: Luau strict mode + Roact + MemoryStore for matchmaking.
## 🔗 Graph
- 부모: [[UGC]]
- 변형: [[Roblox-Studio]]
- Adjacent: [[Unity]] · [[Minecraft]]
## 🤖 LLM 활용
**언제**: Luau snippet 의 generate, Studio API lookup, game design pattern 의 explain.
**언제 X**: TOS-violating exploit / Filtering Enabled bypass — 매 platform-ban 의 risk.
## ❌ 안티패턴
- **`while true do ... end` without `wait()`**: 매 server crash.
- **Trusting client `RemoteEvent` args**: 매 always validate server-side (exploiters 의 send anything).
- **DataStore on every change**: 매 6-second SetAsync limit — debounce + session-locking 의 use.
- **`script.Parent` 의 deep traversal**: 매 brittle — `WaitForChild` 의 use.
## 🧪 검증 / 중복
- Verified (create.roblox.com docs, Roblox 2024 Investor Day).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Luau patterns + DataStore/MemoryStore + Roact |
10_Wiki/Topics/Domain_General/From_Other/Role of Conflict in Narrative.md
+156
View File
@@ -0,0 +1,156 @@
---
id: wiki-2026-0508-role-of-conflict-in-narrative
title: Role of Conflict in Narrative
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Narrative Conflict, Story Conflict, Dramatic Conflict]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [storytelling, writing, narrative, drama]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: english-korean
framework: narrative-craft
---
# Role of Conflict in Narrative
## 매 한 줄
> **"매 story 의 engine 의 conflict — desire vs obstacle"**. Aristotle 의 *Poetics* (335 BCE) 의 *agon* 의 origin, 매 modern beat-sheet (Save the Cat, Hero's Journey) 의 same axis 의 reuse. 매 conflict 의 absence 의 narrative 의 dead — character change 의 vehicle 의 obstacle 의 friction.
## 매 핵심
### 매 Conflict Types (Classical)
1. **Person vs Person** — 매 antagonist clash (Iliad, Breaking Bad).
2. **Person vs Self** — 매 internal moral struggle (Hamlet, Crime and Punishment).
3. **Person vs Society** — 매 institutional pressure (1984, Handmaid's Tale).
4. **Person vs Nature** — 매 survival (The Old Man and the Sea, The Martian).
5. **Person vs Technology** — 매 modern AI/system conflict (Black Mirror, Ex Machina).
6. **Person vs Fate/Supernatural** — 매 destiny challenge (Oedipus, Final Destination).
### 매 Functional Roles
- **Reveals character** — 매 pressure 의 true self.
- **Drives plot** — 매 cause-effect chain.
- **Creates stakes** — 매 reader 의 emotional investment.
- **Forces choice** — 매 character agency 의 demonstrate.
### 매 Structure (3-act + conflict escalation)
1. **Act 1 setup** — 매 inciting incident 의 conflict 의 introduce.
2. **Act 2 confrontation** — 매 rising stakes, midpoint reversal.
3. **Act 3 resolution** — 매 climax (peak conflict) → denouement.
### 매 응용
1. Novel/screenplay drafting — 매 each scene 의 micro-conflict 의 require.
2. Game narrative — 매 quest design 의 obstacle 의 core.
3. Marketing storytelling — 매 customer (hero) vs problem (villain) framing.
4. Therapy / personal narrative — 매 reframing internal conflict.
## 💻 패턴
### Beat sheet template (Markdown)
```markdown
# Story: <Title>
## Protagonist
- Name, want (external goal), need (internal lack).
## Antagonist / Obstacle
- Force opposing the want.
## Beats
1. Opening Image — status quo.
2. Inciting Incident — conflict introduced (page 10).
3. Plot Point 1 — commit to journey (page 25).
4. Midpoint — false victory or false defeat.
5. Plot Point 2 — all-is-lost moment.
6. Climax — peak conflict resolution.
7. Closing Image — mirror of opening, transformed.
```
### Conflict density check (Python)
```python
import re
def conflict_score(scene_text: str) -> float:
# crude heuristic: conflict verbs per 100 words
verbs = re.findall(r"\b(argue|fight|refuse|attack|defy|resist|escape|flee|kill|hate)\b",
scene_text, re.I)
words = len(scene_text.split())
return len(verbs) / max(words, 1) * 100
print(conflict_score(open("scene_1.txt").read()))
```
### Scene goal-conflict-disaster (template)
```markdown
**Scene 12 — The Confrontation**
- Goal: Hero wants to retrieve the key.
- Conflict: Antagonist has set a trap.
- Disaster: Hero gets the key but loses ally.
```
### Dialogue subtext (Luau-flavored example for game dev)
```lua
-- NPC reaction system
local function reactToPlayer(npc, action)
if npc.relationship < 30 and action == "ask_favor" then
npc:say("After what you did? Get out.") -- conflict surfacing
elseif npc.relationship > 70 and action == "ask_favor" then
npc:say("Anything for you.") -- conflict resolved
end
end
```
### LLM-assisted conflict generator (Python, Anthropic SDK)
```python
import anthropic
client = anthropic.Anthropic()
resp = client.messages.create(
model="claude-opus-4-7",
max_tokens=400,
messages=[{
"role": "user",
"content": "Given a protagonist who fears commitment and an antagonist who is their estranged sibling, generate 3 escalating conflict scenes."
}]
)
print(resp.content[0].text)
```
## 매 결정 기준
| 상황 | Conflict type |
|---|---|
| Character study | Person vs Self |
| Thriller | Person vs Person |
| Dystopia | Person vs Society |
| Survival | Person vs Nature |
| Tech ethics | Person vs Technology |
| Tragedy | Person vs Fate |
**기본값**: 매 layered — 매 external (P vs P) + internal (P vs Self) 의 same character 의 simultaneous.
## 🔗 Graph
## 🤖 LLM 활용
**언제**: scene 의 brainstorm, conflict beat 의 escalate, antagonist motivation 의 deepen.
**언제 X**: real human conflict 의 mediation — 매 fictional craft 의 tool, not therapy.
## ❌ 안티패턴
- **Manufactured conflict**: 매 character 의 act stupidly 의 plot 의 force — reader 의 feel manipulated.
- **No internal conflict**: 매 external action 의 only — 매 character 의 flat.
- **Resolved 의 too early**: 매 act 2 의 conflict 의 deflate — sustain 의 climax 의 reach.
- **Antagonist 의 motiveless**: 매 generic villain — 매 antagonist 의 own internal logic 의 require.
## 🧪 검증 / 중복
- Verified (Aristotle *Poetics*, McKee *Story* 1997, Snyder *Save the Cat* 2005).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — 6 conflict types + beat sheet + scene template |
10_Wiki/Topics/Domain_General/From_Other/SOTA.md
+140
View File
@@ -0,0 +1,140 @@
---
id: wiki-2026-0508-sota
title: SOTA
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [State of the Art, SOTA Benchmark, Leaderboard]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [ml, benchmark, evaluation, research, leaderboard]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: agnostic
framework: ml-research
---
# SOTA
## 매 한 줄
> **"매 SOTA = 매 task 의 best 알려진 result"**. State-of-the-Art 의 약자 — 매 ML/research 에서 매 specific benchmark 에 대한 매 highest-scoring approach 의 referrent. 매 2026 년 LLM/diffusion 시대 에서는 매 SOTA 가 매 weeks 단위 로 invalidated 되는 매 fast-moving target.
## 매 핵심
### 매 정의 / scope
- **매 task-bound**: 매 SOTA 는 매 always 매 specific benchmark + 매 metric 에 tied. "매 GPT-5 가 SOTA" → 매 vague. "매 GPT-5 가 매 GSM8K 의 SOTA (98.4%)" → 매 valid.
- **매 dataset split**: 매 same model 도 매 train/eval split 에 따라 매 ranking 변경 가능.
- **매 reproducibility crisis**: 매 SOTA claim 의 매 cherry-picking, 매 hyperparameter tuning, 매 test-set leakage issue 빈번.
### 매 modern (2026) landscape
- **LLM benchmarks**: MMLU-Pro, GPQA Diamond, SWE-Bench Verified, ARC-AGI-2, HLE (Humanity's Last Exam).
- **Coding**: SWE-Bench Verified, LiveCodeBench, Aider polyglot.
- **Vision**: ImageNet-2 (재구성 version), COCO 2025, GenAI-Bench (text-to-image).
- **매 2026 SOTA 양상**: Claude Opus 4.7, GPT-5, Gemini 3.5 Ultra 의 매 leapfrog. 매 monthly invalidation.
### 매 응용
1. **연구 paper**: 매 SOTA result 가 publication 의 매 main currency.
2. **Industry adoption**: 매 SOTA model 의 매 production fine-tune 의 base.
3. **Investment signal**: 매 lab 의 매 SOTA 달성 = 매 funding signal.
## 💻 패턴
### Pattern 1: SOTA evaluation harness
```python
# 매 evaluation 의 reproducibility 확보.
import lm_eval
results = lm_eval.simple_evaluate(
model="hf",
model_args="pretrained=meta-llama/Llama-3.3-70B-Instruct",
tasks=["mmlu_pro", "gpqa_diamond", "math_hard"],
batch_size=8,
num_fewshot=0,
)
print(results["results"])
```
### Pattern 2: SOTA leaderboard scrape
```python
# Papers With Code API.
import requests
r = requests.get(
"https://paperswithcode.com/api/v1/sota/sota-on-mmlu/",
headers={"Accept": "application/json"},
)
top = r.json()["results"][0]
print(f"SOTA: {top['paper']['title']} — {top['metrics']}")
```
### Pattern 3: Statistical-significance check
```python
# 매 SOTA claim 의 매 noise vs 매 real improvement 구분.
from scipy.stats import bootstrap
import numpy as np
baseline = np.array(per_sample_scores_baseline)
candidate = np.array(per_sample_scores_candidate)
diff = candidate - baseline
ci = bootstrap((diff,), np.mean, n_resamples=10_000, confidence_level=0.95)
print(f"Δ mean = {diff.mean():.4f}, 95% CI = {ci.confidence_interval}")
# 매 CI 가 0 포함 → 매 not significant.
```
### Pattern 4: Test-set contamination probe
```python
# 매 model 의 매 train 시 test set 의 leak 확인.
from datasets import load_dataset
test_set = load_dataset("hendrycks/test", split="test")
sample = test_set[0]["question"]
# 매 perplexity test — 매 model 가 매 test sample 의 매 unusually low ppl ?
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
tok = AutoTokenizer.from_pretrained("model-name")
mod = AutoModelForCausalLM.from_pretrained("model-name").cuda()
inputs = tok(sample, return_tensors="pt").to("cuda")
with torch.no_grad():
loss = mod(**inputs, labels=inputs.input_ids).loss
print(f"PPL = {torch.exp(loss).item()}")
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 새 paper 의 SOTA claim | Significance test + 매 reproduction 확인 |
| 매 production model 선택 | 매 SOTA 만 X — latency/cost/license 도 |
| 매 research direction | SOTA 의 매 1-2% 차이 chase X — 매 architectural insight 추구 |
| 매 benchmark saturated (≥99%) | 매 새 benchmark 로 이동 — Goodhart 회피 |
**기본값**: 매 SOTA = 매 starting reference, not endpoint. 매 다양 한 axes (latency, cost, robustness) 평가.
## 🔗 Graph
- 응용: [[Leaderboard]]
- Adjacent: [[Goodharts Law]]
## 🤖 LLM 활용
**언제**: 매 task 의 매 current SOTA 의 매 quick lookup, 매 benchmark 추천.
**언제 X**: 매 LLM 의 매 training cutoff 후 SOTA — 매 stale info, web search 사용.
## ❌ 안티패턴
- **SOTA chasing**: 매 0.1% improvement 만 매 chase — 매 diminishing returns.
- **Single-metric tunnel vision**: 매 accuracy 만 — 매 fairness/latency/robustness 무시.
- **Benchmark hacking**: 매 test-set tuning, 매 prompt engineering for benchmark only.
## 🧪 검증 / 중복
- Verified (Papers With Code; Open LLM Leaderboard; lm-evaluation-harness docs).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — SOTA 정의/landscape/eval harness/contamination probe 정리 |
10_Wiki/Topics/Domain_General/From_Other/Search-Space.md
+155
View File
@@ -0,0 +1,155 @@
---
id: wiki-2026-0508-search-space
title: Search Space
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [State Space, Solution Space, Hypothesis Space]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [algorithms, search, optimization, ai, planning]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: algorithms
---
# Search Space
## 매 한 줄
> **"매 search space = 매 algorithm 의 매 explore-able 모든 candidate 의 set"**. 매 problem 을 매 (state, transition, goal) tuple 로 modeling 시 의 전체 reachable state set. 매 search 의 효율 = 매 1) space 의 size 줄이기 + 2) 매 promising region 의 priorit ize.
## 매 핵심
### 매 정의 components
- **State**: 매 partial / full solution candidate.
- **Initial state**: 매 search 시작 점.
- **Successor function**: 매 state → 매 reachable next states.
- **Goal test**: 매 state 가 매 valid solution 인지.
- **Path cost**: 매 path 의 매 quality metric.
### 매 size scaling
- **Combinatorial explosion**: 매 N-queens 의 N=8 → 매 16M state. N=20 → 매 effectively infinite.
- **Branching factor (b)** × **depth (d)** → b^d.
- **Pruning** (alpha-beta, constraint propagation, branch-and-bound) → 매 effective space ↓.
### 매 응용
1. **Pathfinding**: 매 grid/graph 의 매 cell/node space.
2. **Game AI**: 매 chess/go 의 매 game tree.
3. **Planning**: 매 STRIPS, PDDL 의 매 action sequence space.
4. **NAS**: 매 neural architecture 의 매 hyperparameter space.
5. **LLM reasoning**: 매 chain-of-thought / tree-of-thought 의 매 reasoning tree.
## 💻 패턴
### Pattern 1: Generic search space (BFS)
```python
from collections import deque
def bfs(initial, successors, is_goal):
frontier = deque([(initial, [])])
visited = {initial}
while frontier:
state, path = frontier.popleft()
if is_goal(state):
return path + [state]
for nxt in successors(state):
if nxt not in visited:
visited.add(nxt)
frontier.append((nxt, path + [state]))
return None
```
### Pattern 2: A* with admissible heuristic (search space reduction)
```python
import heapq
def astar(initial, successors, is_goal, heuristic, cost):
pq = [(heuristic(initial), 0, initial, [])]
seen = {}
while pq:
_, g, s, path = heapq.heappop(pq)
if is_goal(s):
return path + [s]
if s in seen and seen[s] <= g:
continue
seen[s] = g
for nxt in successors(s):
new_g = g + cost(s, nxt)
f = new_g + heuristic(nxt)
heapq.heappush(pq, (f, new_g, nxt, path + [s]))
```
### Pattern 3: Constraint propagation (CSP)
```python
# 매 search space 의 매 prune via 매 arc-consistency.
def ac3(domains, constraints):
queue = [(x, y) for x in domains for y in constraints.get(x, [])]
while queue:
x, y = queue.pop(0)
if revise(domains, x, y, constraints):
if not domains[x]:
return False # 매 inconsistent
for z in constraints.get(x, []) - {y}:
queue.append((z, x))
return True
```
### Pattern 4: Tree-of-Thoughts (LLM reasoning space)
```python
# 매 LLM 의 매 reasoning step 을 매 search node 로.
async def tot_search(problem, max_depth=5, beam=3):
frontier = [{"state": problem, "trace": []}]
for d in range(max_depth):
cands = []
for node in frontier:
thoughts = await llm.expand(node["state"], k=beam)
for t in thoughts:
cands.append({"state": t, "trace": node["trace"] + [t]})
# 매 evaluator (LLM-as-judge) 가 매 top-beam pick.
scored = await llm.evaluate(cands)
frontier = sorted(scored, key=lambda x: -x["score"])[:beam]
if any(is_goal(n["state"]) for n in frontier):
break
return frontier[0]["trace"]
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 small finite space | BFS / DFS — 매 complete |
| 매 large but heuristic-able | A* / IDA* |
| 매 huge stochastic | MCTS (UCT) |
| 매 continuous space | gradient-based / Bayesian opt |
| 매 LLM reasoning | Tree-of-Thoughts / Graph-of-Thoughts |
| 매 constraint-rich | CSP solver (Z3, OR-Tools) |
**기본값**: 매 first 매 reformulate problem 으로 매 space 의 size ↓ — 매 algorithm choice 보다 효과 큼.
## 🔗 Graph
- 부모: [[Combinatorial Optimization]]
- 변형: [[State Space]] · [[Hypothesis Space]]
- 응용: [[MCTS]]
## 🤖 LLM 활용
**언제**: 매 problem 의 매 search space modeling 의 매 design 도움.
**언제 X**: 매 매우 narrow domain (chess engine 등) — specialized solver 가 우위.
## ❌ 안티패턴
- **No pruning**: 매 brute-force on b^d=10^15 — 매 wall-clock 의 절망.
- **Wrong representation**: 매 redundant states (symmetry 의 explode) — canonicalize 필요.
- **Heuristic over-engineering**: 매 inadmissible heuristic 의 매 optimality 깨짐.
## 🧪 검증 / 중복
- Verified (Russell & Norvig *AIMA* 4th ed; Yao et al. ToT 2023).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Search Space components/scaling/BFS/A*/CSP/ToT 정리 |
10_Wiki/Topics/Domain_General/From_Other/Search.md
+159
View File
@@ -0,0 +1,159 @@
---
id: wiki-2026-0508-search
title: Search
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Search Algorithm, Information Retrieval, Lookup]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [search, algorithms, ir, retrieval, ai]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: search-algorithms
---
# Search
## 매 한 줄
> **"매 search = 매 space 의 매 traverse 를 매 objective 의 만족 까지"**. 매 algorithmic search (BFS/DFS/A*) 부터 매 information retrieval (lexical + semantic) 까지 매 unify 하는 매 abstraction. 매 2026 년 의 search 는 매 vector embedding + LLM rerank + agent loop 의 매 hybrid stack.
## 매 핵심
### 매 search 의 두 의미
- **Algorithmic search**: 매 state space 의 매 traverse — 매 BFS, DFS, A*, MCTS.
- **Information retrieval (IR)**: 매 corpus 에서 매 query 에 매 relevant document 추출 — 매 BM25, dense vector, hybrid.
### 매 modern stack (2026 IR)
- **매 indexing**: BM25 (lexical) + dense embedding (semantic, e.g., voyage-3, text-embedding-3-large).
- **매 retrieval**: hybrid (BM25 + ANN) → reciprocal rank fusion (RRF).
- **매 rerank**: cross-encoder (e.g., Cohere Rerank 3, BGE-reranker) — top-100 → top-10.
- **매 generative answer**: LLM (Claude Opus 4.7 / GPT-5) 의 매 retrieved context 의 매 grounded answer.
- **매 agent loop**: 매 multi-hop — 매 search → 매 reason → 매 search again.
### 매 응용
1. **RAG**: 매 LLM 의 매 long-tail knowledge 보강.
2. **Code search**: 매 codebase semantic + AST search.
3. **Pathfinding**: 매 robotics, game AI.
4. **Game tree**: 매 chess/go 의 매 minimax + MCTS.
5. **Web search**: 매 Google, Bing, Perplexity, Exa, Tavily.
## 💻 패턴
### Pattern 1: Hybrid retrieval (BM25 + dense)
```python
from rank_bm25 import BM25Okapi
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
class HybridRetriever:
def __init__(self, docs, embeddings, embed_fn):
self.docs = docs
self.bm25 = BM25Okapi([d.split() for d in docs])
self.embs = embeddings
self.embed_fn = embed_fn
def search(self, query, k=10, alpha=0.5):
bm25_scores = self.bm25.get_scores(query.split())
q_emb = self.embed_fn(query)
dense_scores = cosine_similarity([q_emb], self.embs)[0]
# 매 normalize + weighted combine.
bm25_n = (bm25_scores - bm25_scores.min()) / (bm25_scores.ptp() + 1e-9)
dense_n = (dense_scores - dense_scores.min()) / (dense_scores.ptp() + 1e-9)
scores = alpha * dense_n + (1 - alpha) * bm25_n
top = np.argsort(-scores)[:k]
return [(self.docs[i], scores[i]) for i in top]
```
### Pattern 2: Reciprocal rank fusion
```python
def rrf(rankings: list[list[int]], k=60):
"""매 rankings: 각 retriever 의 매 doc-id ordered list."""
scores = {}
for ranking in rankings:
for rank, doc_id in enumerate(ranking):
scores[doc_id] = scores.get(doc_id, 0) + 1 / (k + rank)
return sorted(scores, key=scores.get, reverse=True)
```
### Pattern 3: LLM rerank
```python
import anthropic
client = anthropic.Anthropic()
async def llm_rerank(query: str, candidates: list[str], top_k=5):
prompt = f"""Rate each document 1-10 for relevance to query.
Query: {query}
Documents:
{chr(10).join(f'[{i}] {c[:300]}' for i, c in enumerate(candidates))}
Output JSON: {{"scores": [{{"id": 0, "score": 8.5}}, ...]}}"""
msg = await client.messages.create(
model="claude-opus-4-7",
max_tokens=1024,
messages=[{"role": "user", "content": prompt}],
)
import json, re
data = json.loads(re.search(r"\{.*\}", msg.content[0].text, re.S).group())
ranked = sorted(data["scores"], key=lambda x: -x["score"])[:top_k]
return [candidates[r["id"]] for r in ranked]
```
### Pattern 4: Agent search loop
```python
async def agent_search(question, max_steps=5):
context = []
for step in range(max_steps):
plan = await llm.plan(question, context)
if plan.action == "answer":
return plan.answer
if plan.action == "search":
results = await retriever.search(plan.query, k=5)
context.extend(results)
return await llm.answer(question, context)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 keyword-heavy queries | BM25 우위 |
| 매 semantic / paraphrase | Dense embedding 우위 |
| 매 high-stakes accuracy | Hybrid + cross-encoder rerank |
| 매 multi-hop reasoning | Agent loop (search-reason-search) |
| 매 small corpus (<10k) | In-memory FAISS / numpy |
| 매 large corpus (>1M) | Pinecone / Weaviate / Qdrant / pgvector |
**기본값**: hybrid (BM25 + dense, RRF fusion) + 매 cross-encoder rerank top-100 → 10.
## 🔗 Graph
- 부모: [[Information Retrieval]]
- 변형: [[MCTS]]
- 응용: [[RAG]]
- Adjacent: [[Search Space]] · [[Reranker]]
## 🤖 LLM 활용
**언제**: 매 RAG pipeline 의 매 retrieval / rerank / 매 agent search.
**언제 X**: 매 known-key direct lookup — 매 hash table 의 매 LLM 사용 X.
## ❌ 안티패턴
- **Dense-only**: 매 keyword 의 매 정확 매칭 의 의미 — BM25 보강 필요.
- **No reranker**: top-10 직접 LLM context — 매 noise 많음.
- **Unbounded agent loop**: 매 max_steps 없는 agent — 매 cost 폭발.
## 🧪 검증 / 중복
- Verified (Lin et al. *Pretrained Transformers for Text Ranking* 2021; RRF Cormack 2009).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Search 의 algorithmic + IR 두 의미, 2026 hybrid stack, BM25/dense/RRF/rerank/agent loop 정리 |
10_Wiki/Topics/Domain_General/From_Other/Secondary-Research.md
+158
View File
@@ -0,0 +1,158 @@
---
id: wiki-2026-0508-secondary-research
title: Secondary Research
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Desk Research, Literature Review, Existing-Data Analysis]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [research, methodology, literature-review, knowledge-synthesis]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: agnostic
framework: research-methods
---
# Secondary Research
## 매 한 줄
> **"매 secondary research = 매 existing 의 published / collected data 의 매 analysis"**. 매 primary research (raw 새 data 수집) 의 반대. 매 lit review, 매 meta-analysis, 매 industry report 분석, 매 dataset reuse 다 포함. 매 2026 년 LLM-assisted secondary research 가 매 dominant — 매 single researcher 의 매 weeks → 매 hours.
## 매 핵심
### 매 vs primary research
- **Primary**: 매 직접 collect — survey, interview, experiment, observation. 매 control 큼, 매 cost 큼.
- **Secondary**: 매 already-published 의 reuse — books, papers, gov stats, industry reports, internal docs. 매 cheap, 매 fast, 매 control 작음.
### 매 source taxonomy
- **Academic**: peer-reviewed papers (PubMed, arXiv, Google Scholar, Semantic Scholar, OpenAlex).
- **Government**: census, BLS, OECD, World Bank, KOSIS.
- **Industry**: Gartner, Forrester, IDC, McKinsey, CB Insights, Statista.
- **Internal**: company analytics, post-mortems, design docs.
- **Community**: HN, Reddit, GitHub, blog posts (lower trust, higher recency).
### 매 응용
1. **Lit review**: 매 새 paper 의 매 background section.
2. **Market analysis**: 매 startup 의 매 TAM/SAM/SOM 추정.
3. **Competitor research**: 매 product strategy 의 매 input.
4. **Meta-analysis**: 매 multiple studies 의 매 effect size 통합.
5. **Due diligence**: 매 investment / 매 acquisition 의 매 background.
## 💻 패턴
### Pattern 1: LLM-assisted lit review
```python
import anthropic, asyncio
client = anthropic.AsyncAnthropic()
async def summarize_paper(abstract: str, question: str):
msg = await client.messages.create(
model="claude-opus-4-7",
max_tokens=512,
system="You are a careful research assistant. Cite verbatim.",
messages=[{
"role": "user",
"content": f"Question: {question}\n\nAbstract:\n{abstract}\n\nIs this relevant? If yes, extract key findings + methodology in 3 bullets.",
}],
)
return msg.content[0].text
async def lit_review(question: str, abstracts: list[str]):
results = await asyncio.gather(*[summarize_paper(a, question) for a in abstracts])
return [r for r in results if "not relevant" not in r.lower()]
```
### Pattern 2: arXiv / Semantic Scholar fetch
```python
import requests
def search_semantic_scholar(query: str, limit=20):
r = requests.get(
"https://api.semanticscholar.org/graph/v1/paper/search",
params={
"query": query,
"limit": limit,
"fields": "title,abstract,year,authors,citationCount,openAccessPdf",
},
)
return r.json()["data"]
```
### Pattern 3: Citation graph traversal
```python
def expand_citations(seed_papers, depth=2):
frontier = list(seed_papers)
seen = set(p["paperId"] for p in seed_papers)
for _ in range(depth):
next_frontier = []
for paper in frontier:
r = requests.get(
f"https://api.semanticscholar.org/graph/v1/paper/{paper['paperId']}/references",
params={"fields": "title,abstract,year,citationCount"},
)
for ref in r.json().get("data", []):
pid = ref["citedPaper"]["paperId"]
if pid and pid not in seen:
seen.add(pid)
next_frontier.append(ref["citedPaper"])
frontier = next_frontier
return list(seen)
```
### Pattern 4: Source-trust scoring
```python
def trust_score(source: dict) -> float:
base = {
"peer-reviewed": 0.9,
"preprint": 0.7,
"government": 0.85,
"industry-paid": 0.6,
"blog": 0.4,
"social": 0.2,
}.get(source["type"], 0.3)
age_yrs = 2026 - source["year"]
decay = max(0.5, 1 - 0.05 * age_yrs)
citations = min(1.0, source.get("citations", 0) / 100)
return base * decay * (0.6 + 0.4 * citations)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 새 topic 빠른 overview | LLM survey + 매 5-10 review papers |
| 매 medical / safety claim | Cochrane / systematic review only |
| 매 market size estimation | Triangulate 3+ sources (Gartner + government + internal) |
| 매 historical trend | Government/longitudinal data |
| 매 cutting-edge tech | arXiv (acknowledge non-peer-reviewed) |
**기본값**: 매 source diversification — 매 single source 의 매 trust X. 매 triangulate ≥3.
## 🔗 Graph
- 부모: [[Research Methodology]]
- 응용: [[Literature Review]]
- Adjacent: [[Knowledge Synthesis]]
## 🤖 LLM 활용
**언제**: 매 abstract 의 매 relevance filter, 매 cross-paper synthesis, 매 lit review draft.
**언제 X**: 매 LLM 의 매 hallucinated citations — 매 always 매 source verify.
## ❌ 안티패턴
- **Single-source bias**: 매 매 1 paper / 매 1 industry report 만 의 매 conclusion.
- **Citation laundering**: 매 LLM 생성 citation 의 매 unverified copy-paste.
- **Stale data**: 매 fast-moving field (LLM, crypto) 의 매 2-yr-old report 의 매 current 처럼 사용.
## 🧪 검증 / 중복
- Verified (Cooper *Research Synthesis and Meta-Analysis* 5th ed; PRISMA 2020 guidelines).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Secondary Research 의 vs primary, source taxonomy, LLM lit-review pipeline, citation graph, trust scoring 정리 |
10_Wiki/Topics/Domain_General/From_Other/Sociology of Knowledge.md
+120
View File
@@ -0,0 +1,120 @@
---
id: wiki-2026-0508-sociology-of-knowledge
title: Sociology of Knowledge
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Wissenssoziologie, Social Construction of Knowledge, Mannheim Sociology]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [sociology, epistemology, philosophy, knowledge, social-theory]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: agnostic
framework: social-theory
---
# Sociology of Knowledge
## 매 한 줄
> **"매 모든 knowledge 는 매 social context 에 매 embedded"**. Karl Mannheim (*Ideology and Utopia*, 1929) 가 founding 한 매 sub-discipline — 매 truth claims, 매 scientific paradigm, 매 even mathematical conventions 까지 매 producing community 의 매 social structure 의 reflection 이라고 본다. 매 Berger & Luckmann (*Social Construction of Reality*, 1966) 가 매 modern reformulation.
## 매 핵심
### 매 founders / lineage
- **Marx**: 매 economic base → 매 ideological superstructure 의 매 proto-thesis.
- **Mannheim** (1929): 매 ideology vs utopia, 매 *Seinsverbundenheit des Wissens* (knowledge's existential bondedness).
- **Berger & Luckmann** (1966): 매 reality 의 매 social construction — externalization → objectivation → internalization.
- **Kuhn** (1962): 매 paradigm + 매 normal/revolutionary science — 매 scientific knowledge 의 매 community 의 conventions 으로.
- **SSK / Strong Programme** (Bloor, Edinburgh, 1976): 매 even successful science 의 매 sociological explanation 가능.
- **Latour ANT**: 매 actor-network — 매 human + non-human 의 매 hybrid network 가 매 facts 생산.
### 매 핵심 thesis
- **매 standpoint epistemology**: 매 knower 의 매 social position 이 매 known 에 영향.
- **매 paradigm-bound**: 매 "fact" 자체 가 매 prevailing paradigm 안 에서 만 sense 함.
- **매 distinction (Bourdieu)**: 매 cultural capital, 매 habitus 가 매 academic / scientific 의 매 selection 좌우.
### 매 응용
1. **Science studies**: 매 lab ethnography (Latour & Woolgar *Laboratory Life*).
2. **Tech history**: 매 silicon valley 의 매 culture 가 매 tech direction 형성.
3. **AI ethics**: 매 ML model 의 매 bias 가 매 producing community 의 매 reflection.
4. **Knowledge management**: 매 tacit knowledge (Polanyi/Nonaka) 의 매 social embedding.
## 💻 패턴
(매 mostly conceptual domain — 매 code patterns 적음, but 매 modern computational social science 의 적용)
### Pattern 1: Citation network analysis (매 paradigm detection)
```python
import networkx as nx
from sklearn.cluster import SpectralClustering
# 매 OpenAlex API 의 citation graph build.
def build_citation_graph(seed_papers):
G = nx.DiGraph()
for p in seed_papers:
G.add_node(p["id"], **p)
for ref in p["referenced_works"]:
G.add_edge(p["id"], ref)
return G
# 매 community detection — 매 paradigm proxy.
def detect_paradigms(G, k=5):
A = nx.to_scipy_sparse_array(G.to_undirected())
sc = SpectralClustering(n_clusters=k, affinity="precomputed_nearest_neighbors")
labels = sc.fit_predict(A)
return dict(zip(G.nodes, labels))
```
### Pattern 2: Bias-in-corpus probe
```python
# 매 ML training corpus 의 매 socio-demographic bias quantify.
from collections import Counter
import re
def occupation_gender_skew(corpus, occupations, pronouns):
counts = {occ: Counter() for occ in occupations}
for doc in corpus:
for occ in occupations:
for match in re.finditer(rf"\b{occ}\b\s+\w+\s+(\w+)", doc, re.I):
token = match.group(1).lower()
if token in pronouns:
counts[occ][pronouns[token]] += 1
return counts
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 scientific consensus 의 origin 분석 | Kuhn paradigm + 매 citation network |
| 매 ML bias audit | Standpoint epistemology — 매 producer demographics |
| 매 organizational tacit knowledge | Polanyi/Nonaka SECI model |
| 매 tech adoption pattern | Latour ANT — 매 human + non-human |
**기본값**: 매 reflexive — 매 자기 의 분석 도 매 같은 sociological forces 의 subject.
## 🔗 Graph
- 부모: [[Epistemology]]
- 응용: [[Tacit Knowledge]]
## 🤖 LLM 활용
**언제**: 매 academic discipline 의 매 origin / school mapping, 매 paradigm 식별.
**언제 X**: 매 LLM 자체 가 매 producing community 의 매 bias 의 carrier — 매 reflexive caution.
## ❌ 안티패턴
- **Vulgar relativism**: 매 모든 knowledge 가 매 equally valid — Bloor 의 strong programme 의 매 misreading.
- **Reductionism**: 매 모든 fact 의 매 social cause 만 — 매 material/empirical evidence 무시.
- **Self-exemption**: 매 sociology of knowledge 의 매 itself 에 매 적용 X — 매 reflexivity 결핍.
## 🧪 검증 / 중복
- Verified (Mannheim *Ideology and Utopia*; Berger & Luckmann *Social Construction of Reality*; Bloor *Knowledge and Social Imagery*).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Sociology of Knowledge 의 lineage (Marx → Mannheim → Berger/Luckmann → SSK → ANT), thesis, computational adaptations 정리 |
10_Wiki/Topics/Domain_General/From_Other/Soft-Skills-Development.md
+135
View File
@@ -0,0 +1,135 @@
---
id: wiki-2026-0508-soft-skills-development
title: Soft Skills Development
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [People Skills, Interpersonal Skills, Power Skills, Durable Skills]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [career, professional-development, communication, leadership, eq]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: agnostic
framework: career-development
---
# Soft Skills Development
## 매 한 줄
> **"매 soft skills = 매 hard skills 의 매 force-multiplier"**. 매 communication, 매 emotional intelligence, 매 collaboration, 매 negotiation, 매 leadership 등 매 codify-hard 한 interpersonal skills. 매 2026 년 LLM 시대 에서는 매 hard skills 의 매 commoditize → 매 soft skills 가 매 differentiator. World Economic Forum *Future of Jobs 2025* 의 top-10 의 매 7 가 soft skills.
## 매 핵심
### 매 taxonomy (modern WEF 2025)
1. **Analytical thinking**: 매 problem 의 매 decompose, 매 evidence weighing.
2. **Resilience / flexibility**: 매 setback 후 의 매 recovery + 매 ambiguity tolerance.
3. **Leadership / social influence**: 매 vision casting, 매 buy-in 형성.
4. **Curiosity / lifelong learning**: 매 self-directed upskilling.
5. **Creativity**: 매 novel combinations 생성.
6. **Empathy / active listening**: 매 emotional perspective-taking.
7. **Self-efficacy / motivation**: 매 internal drive.
8. **Talent management**: 매 team 의 매 develop / 매 retain.
9. **Service orientation**: 매 customer empathy.
10. **Systems thinking**: 매 cause-effect web 매 mapping.
### 매 development modalities
- **Deliberate practice**: 매 specific feedback loop, 매 challenge zone (Ericsson).
- **Reflection**: 매 journaling, 매 after-action review (AAR).
- **Mentorship / coaching**: 매 1:1 의 매 high-bandwidth feedback.
- **Cross-functional rotation**: 매 different teams / domains 의 exposure.
- **Toastmasters / debate clubs**: 매 communication 의 매 deliberate venue.
### 매 measurement (어려움)
- **360-degree feedback**: 매 peer/manager/report 의 매 anonymous input.
- **Behavioral interview**: STAR (Situation-Task-Action-Result) format.
- **Peer ratings over time**: 매 trend signal.
- **매 caveat**: 매 Goodhart — 매 metric 의 매 game-able.
## 💻 패턴
### Pattern 1: After-action review template
```markdown
# AAR — [Project/Event Name]
**Date**: 2026-05-10 **Owner**: [name]
## 매 What was supposed to happen?
- ...
## 매 What actually happened?
- ...
## 매 What went well?
- ... (매 specific behaviors, not vague praise)
## 매 What could be improved?
- ... (매 systems-level, 매 not blame)
## 매 Lessons / Action items
- [ ] [Action] — owner — by [date]
```
### Pattern 2: Active-listening framework (HEAR)
```text
H — Halt: 매 own response generation 의 매 pause.
E — Engage: 매 eye contact, 매 verbal acknowledgment ("I see").
A — Anticipate: 매 speaker 의 매 emotion / unstated need 의 매 detect.
R — Replay: 매 paraphrase back ("So what I'm hearing is...").
```
### Pattern 3: Feedback delivery (SBI model)
```text
S — Situation: "In yesterday's standup..."
B — Behavior: "...you interrupted Maria three times..."
I — Impact: "...which I think made her stop sharing her concerns."
매 specific + 매 behavioral + 매 impact-focused. 매 not 매 personality attack.
```
### Pattern 4: Negotiation prep (BATNA)
```text
1. 매 internal: 매 your interests vs positions.
2. 매 BATNA: 매 Best Alternative To Negotiated Agreement.
3. 매 ZOPA: 매 Zone of Possible Agreement (overlap with counterparty).
4. 매 anchor: 매 first offer 의 매 prepare.
5. 매 walk-away: 매 reservation point.
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 IC 단계 의 시작 | Communication + 매 collaboration 우선 |
| 매 senior IC / staff | Influence + 매 mentorship |
| 매 manager 전환 | EQ + 매 difficult conversations + 매 delegation |
| 매 director+ | Strategic communication + 매 org politics |
| 매 founder | All-of-the-above + 매 storytelling + 매 negotiation |
**기본값**: 매 1 skill 의 매 6 month focus — 매 broad shallow X.
## 🔗 Graph
- 응용: [[Conflict Resolution]]
- Adjacent: [[Deliberate Practice]] · [[Growth Mindset]]
## 🤖 LLM 활용
**언제**: 매 difficult conversation 의 매 rehearsal, 매 feedback draft 의 매 SBI-frame, 매 written communication 의 매 tone polish.
**언제 X**: 매 actual interpersonal interaction — 매 LLM 의 매 substitute X. 매 face-to-face practice 필수.
## ❌ 안티패턴
- **"Soft" = unimportant**: 매 misnomer — 매 hard skills 의 매 leverage.
- **One-shot training**: 매 weekend workshop 만 — 매 deliberate practice 부족.
- **Unmeasured improvement**: 매 feedback loop 없는 self-development — 매 plateau.
- **Mimicry only**: 매 charismatic leader 의 매 behavior copy — 매 authenticity 결여.
## 🧪 검증 / 중복
- Verified (WEF *Future of Jobs Report 2025*; Ericsson *Peak* 2016; Goleman *Emotional Intelligence* 1995).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Soft Skills 의 WEF 2025 taxonomy, modalities, AAR/HEAR/SBI/BATNA frameworks 정리 |
10_Wiki/Topics/Domain_General/From_Other/Supercell의 모바일 게임 개발.md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-supercell의-모바일-게임-개발
title: Supercell의 모바일 게임 개발
category: 10_Wiki/Topics
status: duplicate
canonical_id: wiki-2026-0508-mobile-game-development
duplicate_of: "[[Mobile Game Development]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, mobile-games, supercell, game-dev]
last_reinforced: 2026-05-10
github_commit: pending
---
# Supercell의 모바일 게임 개발
> **이 문서는 [[Mobile Game Development]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (Supercell-specific aspects)
- **Cell 조직**: 매 small autonomous team (5-7명) — 매 game 단위 cell. 매 kill switch culture (Clash Mini, Rush Wars 종료).
- **Long-tail live-ops**: Clash of Clans (2012), Hay Day (2012), Clash Royale (2016), Brawl Stars (2017), Squad Busters (2024) — 매 decade-long retention 의 representative case.
- **Tech stack**: 매 자체 engine (C++), AWS infra, ML matchmaking (TrueSkill 변형).
- **Soft launch playbook**: Canada/Finland/Australia 3-6개월 telemetry → global launch or kill.
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/Team Culture & Onboarding (팀 문화 및 온보딩).md
+31
View File
@@ -0,0 +1,31 @@
---
id: wiki-2026-0508-team-culture-onboarding-팀-문화-및-온
title: "Team Culture & Onboarding (팀 문화 및 온보딩)"
category: 10_Wiki/Topics
status: duplicate
canonical_id: team-culture-and-onboarding
duplicate_of: "[[Team Culture and Onboarding]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, culture, onboarding, korean]
last_reinforced: 2026-05-10
github_commit: pending
---
# Team Culture & Onboarding (팀 문화 및 온보딩)
> **이 문서는 [[Team Culture and Onboarding]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (specialization aspects)
- 매 한국어 title variant 의 same topic.
- 매 팀 문화 + 신규 입사자 onboarding flow 의 내용 의 canonical 의 동일.
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/Understanding Complex Systems.md
+188
View File
@@ -0,0 +1,188 @@
---
id: wiki-2026-0508-understanding-complex-systems
title: Understanding Complex Systems
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Complexity Science, Complex Adaptive Systems, CAS]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [complexity, systems-thinking, emergence, networks]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: Python
framework: NetworkX / Mesa / SciPy
---
# Understanding Complex Systems
## 매 한 줄
> **"매 부분의 합 그 이상 — 매 emergence"**. Santa Fe Institute 1984 founding 이후 complexity science 는 economics, biology, AI safety 까지 확장됐고, 2026 현재 ABM + GNN + dynamical systems 의 hybrid analysis 가 standard toolkit이다.
## 매 핵심
### 매 정의 axes
- **Many components**: 매 대량의 interacting agent.
- **Nonlinearity**: small cause → large effect (butterfly).
- **Emergence**: macro pattern not reducible to micro rules.
- **Adaptation**: agent rule 의 evolution (CAS).
- **Self-organization**: external designer 없이 ordered structure.
### 매 phenomena
- **Phase transitions** (percolation, Ising).
- **Power laws / scale-free networks** (Barabási 1999).
- **Chaos & strange attractors** (Lorenz 1963).
- **Synchronization** (Kuramoto oscillators).
- **Critical brain hypothesis** (Beggs & Plenz 2003).
### 매 응용
1. Epidemic modeling (COVID-19, agent-based + network).
2. Financial market (heavy tails, flash crashes).
3. AI safety: emergent behaviors in LLM scaling, multi-agent.
4. Climate tipping points.
5. Urban / supply chain resilience.
## 💻 패턴
### Game of Life — emergence demo
```python
import numpy as np
def step(grid):
n = sum(np.roll(np.roll(grid, i, 0), j, 1)
for i in (-1, 0, 1) for j in (-1, 0, 1)
if (i, j) != (0, 0))
return ((n == 3) | ((grid == 1) & (n == 2))).astype(int)
g = np.random.binomial(1, 0.3, (200, 200))
for _ in range(500):
g = step(g)
```
### Scale-free network (Barabási–Albert)
```python
import networkx as nx
G = nx.barabasi_albert_graph(n=10_000, m=3, seed=42)
degrees = [d for _, d in G.degree()]
# verify power-law
import powerlaw
fit = powerlaw.Fit(degrees, discrete=True)
print(fit.alpha, fit.xmin, fit.distribution_compare("power_law", "lognormal"))
```
### Kuramoto synchronization
```python
import numpy as np
from scipy.integrate import odeint
def kuramoto(theta, t, omega, K, N):
dtheta = omega.copy()
for i in range(N):
dtheta[i] += (K/N) * np.sum(np.sin(theta - theta[i]))
return dtheta
N, K = 100, 1.5
omega = np.random.normal(0, 1, N)
theta0 = np.random.uniform(0, 2*np.pi, N)
t = np.linspace(0, 50, 1000)
sol = odeint(kuramoto, theta0, t, args=(omega, K, N))
# order parameter r(t)
r = np.abs(np.exp(1j * sol).mean(axis=1))
```
### SIR epidemic on network
```python
import networkx as nx, random
def sir(G, beta=0.05, gamma=0.01, init=5, T=200):
state = {n: "S" for n in G}
for n in random.sample(list(G), init): state[n] = "I"
history = []
for _ in range(T):
new = state.copy()
for n, s in state.items():
if s == "I":
if random.random() < gamma: new[n] = "R"
for nb in G.neighbors(n):
if state[nb] == "S" and random.random() < beta:
new[nb] = "I"
state = new
history.append((sum(v=="S" for v in state.values()),
sum(v=="I" for v in state.values()),
sum(v=="R" for v in state.values())))
return history
```
### Lyapunov exponent (logistic map)
```python
import numpy as np
def lyapunov(r, x0=0.5, n=10_000, burn=1000):
x = x0
for _ in range(burn): x = r*x*(1-x)
s = 0.0
for _ in range(n):
x = r*x*(1-x)
s += np.log(abs(r - 2*r*x) + 1e-12)
return s / n
for r in np.linspace(2.5, 4.0, 16):
print(f"r={r:.2f} λ={lyapunov(r):+.4f}")
```
### Causal emergence via effective info (PyPhi-lite idea)
```python
# coarse-grain & measure mutual info gain — 매 Hoel 2017
def effective_info(P_micro, grouping):
# P_micro: (S, S) transition matrix
# grouping: list of macro-state index per micro-state
import numpy as np
macro = max(grouping) + 1
P_macro = np.zeros((macro, macro))
for i, gi in enumerate(grouping):
for j, gj in enumerate(grouping):
P_macro[gi, gj] += P_micro[i, j]
P_macro /= P_macro.sum(axis=1, keepdims=True) + 1e-12
return P_macro
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Local rules, emergent macro | Agent-based (Mesa, NetLogo) |
| Network structure matters | NetworkX / igraph + null models |
| Continuous coupled oscillators | Kuramoto / ODE |
| Discrete-time chaos | Iterated maps + Lyapunov |
| Real data, latent dynamics | SINDy / Koopman / NeuralODE |
**기본값**: NetworkX + Mesa for structure+dynamics, SciPy for ODE, powerlaw for tail fit.
## 🔗 Graph
- 부모: [[Systems Theory]] · [[Nonlinear Dynamics]]
- 응용: [[Pedestrian-Modeling]]
- Adjacent: [[Entropy in Information Theory|Information Theory]] · [[AI_Safety_and_Alignment|AI Safety]]
## 🤖 LLM 활용
**언제**: model scaffolding, parameter sweep, hypothesis enumeration, literature 정리.
**언제 X**: long-horizon stability claim — 매 numerical proof / theorem 직접 검증.
## ❌ 안티패턴
- **Power-law claim 의 over-fit**: 매 lognormal vs power-law 비교 검증 필수 (Clauset 2009).
- **Emergence as magic**: 매 정의 명확화 — weak (epistemic) vs strong (ontological).
- **Single ABM run**: Monte Carlo ensemble 필수 (≥100 runs).
- **Network metric without null**: 매 configuration model baseline 비교.
## 🧪 검증 / 중복
- Verified (Mitchell "Complexity: A Guided Tour", SFI lectures, Strogatz "Nonlinear Dynamics and Chaos", Newman "Networks" 2nd ed).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — emergence + networks + chaos pattern set |
10_Wiki/Topics/Domain_General/From_Other/Victimhood-Narratives.md
+166
View File
@@ -0,0 +1,166 @@
---
id: wiki-2026-0508-victimhood-narratives
title: Victimhood Narratives
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Victim Narrative, Tendency for Interpersonal Victimhood, TIV]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [psychology, sociology, narrative, ethics]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: english-korean
framework: social-psychology
---
# Victimhood Narratives
## 매 한 줄
> **"매 personal/group identity 의 wronged-self 의 frame"**. Gabay et al. (2020) 의 *Tendency for Interpersonal Victimhood* (TIV) 의 4-factor scale 의 academic 의 codify. 매 narrative 의 mobilizing power 의 strong — collective grievance, political identity, online discourse 의 central. 매 legitimate harm 의 acknowledge 의 vs 매 strategic identity 의 instrumentalize 의 distinction 의 critical.
## 매 핵심
### 매 TIV Four Factors (Gabay 2020)
1. **Need for recognition** — 매 victim status 의 external validate.
2. **Moral elitism** — 매 self / in-group 의 moral 의 superior 의 see.
3. **Lack of empathy** — 매 own pain focus, others' 의 dismiss.
4. **Rumination** — 매 past offense 의 repeated 의 replay.
### 매 Functions
- **Solidarity** — 매 in-group 의 cohesion 의 strengthen.
- **Mobilization** — 매 collective action 의 fuel.
- **Moral leverage** — 매 demand 의 legitimacy 의 add.
- **Avoidance** — 매 personal agency 의 displace 의 onto external.
### 매 Risks
- **Competitive victimhood** — 매 group 의 grievance Olympics.
- **Identity rigidity** — 매 victim 의 permanent 의 self-cast.
- **Discourse polarization** — 매 zero-sum 의 frame.
- **Manipulation** — 매 demagogue 의 exploit.
### 매 응용
1. Social psych research — TIV scale 의 measure.
2. Conflict mediation — 매 dual-narrative recognition 의 break impasse.
3. Political analysis — 매 movement rhetoric 의 deconstruct.
4. Therapy — 매 individual 의 reframing 의 agency 의 reclaim.
## 💻 패턴
### TIV scale scoring (Python)
```python
# Gabay et al. 2020 — 8 items per factor, 5-point Likert
def tiv_score(responses: dict[str, list[int]]) -> dict[str, float]:
factors = ["need_recognition", "moral_elitism", "empathy_lack", "rumination"]
return {f: sum(responses[f]) / len(responses[f]) for f in factors}
scores = tiv_score({
"need_recognition": [4, 5, 3, 5, 4, 4, 3, 5],
"moral_elitism": [3, 4, 4, 3, 4, 3, 4, 4],
"empathy_lack": [2, 3, 2, 3, 2, 2, 3, 2],
"rumination": [5, 5, 4, 5, 5, 4, 5, 5],
})
print(scores) # {'need_recognition': 4.13, ...}
```
### Narrative frame classifier (LLM)
```python
import anthropic
client = anthropic.Anthropic()
def classify_frame(text: str) -> str:
resp = client.messages.create(
model="claude-opus-4-7",
max_tokens=200,
messages=[{
"role": "user",
"content": f"""Classify the narrative frame of this passage as one of:
- legitimate_grievance (specific, verifiable harm + agency)
- victimhood_identity (TIV-style: rumination, moral elitism, no agency)
- mixed
- neither
Passage: {text}
Return JSON: {{"frame": "...", "rationale": "..."}}"""
}]
)
return resp.content[0].text
```
### Dual-narrative mediation template
```markdown
**Both/And reframe**
Group A's harm: <specific historical/ongoing>.
Group B's harm: <specific historical/ongoing>.
Shared interest: <identified common ground>.
Action item:
- A acknowledges B's <specific>.
- B acknowledges A's <specific>.
- Joint commitment: <forward action>.
```
### Discourse rumination detector (NLP)
```python
import re
def rumination_index(text: str) -> float:
# Crude: repetition of grievance markers
markers = re.findall(r"\b(again|always|still|never|every time|once more)\b",
text, re.I)
sentences = re.split(r"[.!?]", text)
return len(markers) / max(len(sentences), 1)
```
### Survey deployment (Qualtrics-style YAML)
```yaml
survey: TIV-2020-short
items:
- id: tiv_nr_1
text: "It is important to me that people who have hurt me acknowledge my pain."
scale: likert-5
- id: tiv_me_1
text: "I have a higher moral standard than most people."
scale: likert-5
# ... 32 items total
```
## 매 결정 기준
| 상황 | Frame |
|---|---|
| Verifiable specific harm + agency call | Legitimate grievance |
| Diffuse identity claim, rumination, no agency | TIV-style |
| Power asymmetry context | 매 careful — 매 dismissal 의 risk |
| Therapy 1:1 | Reframe 의 agency 의 restore |
| Public discourse | Acknowledge harm + reject zero-sum |
**기본값**: 매 specific harm 의 acknowledge AND 매 identity-rigidity 의 caution.
## 🔗 Graph
## 🤖 LLM 활용
**언제**: narrative frame 의 analyze, dual-acknowledgment 의 draft, TIV survey 의 design.
**언제 X**: 매 individual 의 lived experience 의 dismiss — 매 specific harm 의 verify, 매 LLM 의 not arbiter.
## ❌ 안티패턴
- **Blanket dismissal**: 매 "victim mentality" label 의 specific harm 의 erase.
- **Blanket validation**: 매 every claim 의 unconditional accept — 매 manipulation vector.
- **Zero-sum framing**: 매 only one group 의 victim 의 — 매 dual-narrative 의 ignore.
- **Therapy 의 weaponize**: 매 TIV scale 의 ad hominem 의 use.
- **Historical denial**: 매 documented systemic harm 의 "narrative" 의 reduce.
## 🧪 검증 / 중복
- Verified (Gabay et al. 2020, *Personality and Individual Differences* 165:110134).
- 신뢰도 A (academic) / B (politicized application — context-dependent).
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — TIV factors + classifier patterns + mediation template |
10_Wiki/Topics/Domain_General/From_Other/WoW 토큰 및 PLEX.md
+34
View File
@@ -0,0 +1,34 @@
---
id: wiki-2026-0508-wow-토큰-및-plex
title: WoW 토큰 및 PLEX
category: 10_Wiki/Topics
status: duplicate
canonical_id: virtual-economy-rmt-bridge
duplicate_of: "[[Virtual Economy RMT Bridge]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, mmo-economy, rmt, wow, eve-online]
last_reinforced: 2026-05-10
github_commit: pending
---
# WoW 토큰 및 PLEX
> **이 문서는 [[Virtual Economy RMT Bridge]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (specialization aspects)
- WoW Token (Blizzard, 2015~) 와 EVE Online PLEX (CCP, 2008~) 는 매 publisher-sanctioned RMT bridge 의 매 대표 instance.
- 매 mechanism: real money → in-game currency (gold/ISK) 의 매 official conversion. Gray-market RMT 의 매 demand 를 매 internalize 하여 매 ban 대신 매 revenue stream 으로 전환.
- 매 economic role: gold sink (token consumed on use) + price discovery (auction-house style float price).
- 매 2026 state: WoW Token 매 ~$20 fixed USD, gold price floats. PLEX 매 multi-tier (game time, Omega, marketplace currency).
## 🔗 Graph
- 관련: [[인플레이션(Inflation)]] · [[자원 로지스틱스(Resource Logistics)]] · [[가상 경제 시스템의 구조적 무결성 분석]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/Working-Backwards.md
+161
View File
@@ -0,0 +1,161 @@
---
id: wiki-2026-0508-working-backwards
title: Working Backwards
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [PR-FAQ, Amazon Working Backwards, Press Release First]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [product-management, amazon, framework, decision-making]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: N/A
framework: PR-FAQ Document
---
# Working Backwards
## 매 한 줄
> **"매 customer 부터 거꾸로"**. Amazon이 1990s 말 정착시킨 product development framework — 매 internal press release 와 FAQ 를 먼저 작성한 뒤 거기서 spec 를 도출. 2026 현재 Amazon, Coupang, 토스 등 product-led org 의 standard discipline.
## 매 핵심
### 매 5개 customer question
1. **Who is the customer?** 매 구체적 segment.
2. **What is the customer problem or opportunity?**
3. **What is the most important customer benefit?** (선택 X — 1개)
4. **How do you know what customers need or want?** (data, interview, signal)
5. **What does the customer experience look like?** (end-to-end flow)
### 매 PR-FAQ 구조
- **Press Release** (1 page): headline, sub-headline, summary, problem, solution, leader quote, customer quote, how to get started.
- **External FAQ** (1-2 page): customer-facing 의 anticipated Q.
- **Internal FAQ** (3-5 page): build cost, risk, business model, dependency, metric.
### 매 응용
1. New product 0→1 (Kindle, AWS S3 의 origin docs는 PR-FAQ).
2. Major feature launch 의 alignment.
3. Roadmap prioritization (PR-FAQ readable → ship-worthy).
## 💻 패턴
### PR-FAQ template (Markdown)
```markdown
# [Product Name] launches [date]
**[Punchy 1-line headline]**
[Sub-headline: 1-2 sentence customer benefit]
**SEATTLE — [Date]** — Today, [company] announced [product]. [Product]
solves [problem] for [customer segment] by [solution mechanism].
> "[Customer quote — specific, emotional, concrete benefit]"
> — [Persona name, role]
> "[Internal leader quote — vision]"
> — [Leader, title]
To get started, customers can [single clear CTA].
---
## FAQ — External
**Q: How is this different from [competitor]?**
A: ...
**Q: How much does it cost?**
A: ...
## FAQ — Internal
**Q: What's the build cost & timeline?**
A: ...
**Q: What's the customer #1 success metric?**
A: ... (single number, owned)
**Q: What's the biggest risk and how do we mitigate?**
A: ...
**Q: What dependencies does this have?**
A: ...
**Q: What's the kill criterion?**
A: ... (numeric trigger to stop)
```
### Five-Whys driving from PR back to spec
```
PR claim: "Latency under 200ms p99"
Why? → Customer task abandons at >300ms (data: session log)
Why? → Cognitive flow break
Why? → Page reflow during quote refresh
Why? → Server-side rendering on every poll
Why? → No client-side delta caching
→ Spec: implement WS-based delta + client cache. Owner: X. Metric: p99<200ms.
```
### PR-FAQ readiness rubric
```
| Criterion | Score 1-5 |
|----------------------------------------|-----------|
| Headline passes "would I click" test | |
| Customer quote sounds like real user | |
| #1 benefit is concrete & measurable | |
| Internal FAQ has kill criterion | |
| Dependency list complete | |
| Metric is single number with owner | |
Total ≥ 24/30 → ship-worthy review.
```
### Inverted backlog prioritization
```python
# 매 score = (PR clarity) * (customer benefit magnitude) / (build cost * risk)
def working_backwards_score(pr_clarity, benefit, cost, risk):
return (pr_clarity * benefit) / (cost * risk + 1e-6)
backlog = sorted(items, key=lambda i: -working_backwards_score(**i))
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 0→1 new product | Full PR-FAQ before any code |
| Major feature in existing product | Mini PR-FAQ (1 page total) |
| Bug fix / small improvement | Skip — JIRA ticket OK |
| Stakeholder misalignment | PR-FAQ as alignment artifact |
| Roadmap prioritization | Compare PR-FAQ readability head-to-head |
**기본값**: any project >2 engineer-weeks → PR-FAQ first.
## 🔗 Graph
- 변형: [[Press Release First]]
- Adjacent: [[Lean Startup]]
## 🤖 LLM 활용
**언제**: PR draft 초안, FAQ Q-set 생성, customer quote persona 생성, 다른 PR-FAQ 와의 consistency check.
**언제 X**: 매 actual customer voice 의 substitute X — 매 real interview 가 source of truth.
## ❌ 안티패턴
- **Solution-first PR**: 매 problem 정의 없이 feature listing — 매 reverse 의 본질 무시.
- **Vague metric**: "improve experience" 의 X — 매 single number + owner.
- **No kill criterion**: 매 internal FAQ 에 numeric stop trigger 필수.
- **PR after build**: 매 retroactive PR — 매 Working Backwards 의 X. 매 build 전에 작성.
- **Buzzword quote**: customer quote 가 marketing speak — real user transcript 기반.
## 🧪 검증 / 중복
- Verified (Bryar & Carr "Working Backwards" 2021, Amazon shareholder letters 1997-, Coupang internal docs).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — PR-FAQ template + readiness rubric |
10_Wiki/Topics/Domain_General/From_Other/가상 경제 시스템.md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-가상-경제-시스템
title: 가상 경제 시스템
category: 10_Wiki/Topics
status: duplicate
canonical_id: wiki-2026-0508-virtual-economy-system
duplicate_of: "[[Virtual-Economy-System]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, game-economy, virtual-economy]
last_reinforced: 2026-05-10
github_commit: pending
---
# 가상 경제 시스템
> **이 문서는 [[Virtual-Economy-System]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (specialization aspects)
- 매 게임 내부 통화 · 재화 · 거래 mechanics 의 통합 framework.
- Faucet → Pool → Sink 구조로 인플레이션 / 디플레이션 통제.
- F2P · live-service game 의 monetization layer 와 직접 결합.
## 🔗 Graph
- 관련: [[가상 화폐 (Virtual Currency)]] · [[수도꼭지와 배수구(Faucets and Sinks)]] · [[인플레이션(Inflation)]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/가상 경제 시스템의 구조적 무결성 분석.md
+34
View File
@@ -0,0 +1,34 @@
---
id: wiki-2026-0508-가상-경제-시스템의-구조적-무결성-분석
title: 가상 경제 시스템의 구조적 무결성 분석
category: 10_Wiki/Topics
status: duplicate
canonical_id: virtual-economy-integrity
duplicate_of: "[[Virtual Economy Integrity]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, virtual-economy, mmo-design, sinks-faucets]
last_reinforced: 2026-05-10
github_commit: pending
---
# 가상 경제 시스템의 구조적 무결성 분석
> **이 문서는 [[Virtual Economy Integrity]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (specialization aspects)
- 매 framework: faucets (gold generation) ↔ sinks (gold removal) 의 매 balance 가 매 long-term integrity 결정.
- 매 failure modes: hyperinflation (sink 부족), deflation/hoarding (faucet 부족), bot/RMT (parallel economy), dupe exploit (instant supply shock).
- 매 measurement: CPI-style basket (top trade goods price index), Gini coefficient (wealth distribution), velocity (gold turnover/day).
- 매 case studies: Diablo III RMAH 폐지 (2014), EVE Online ISK 안정성, Path of Exile barter economy.
## 🔗 Graph
- 관련: [[인플레이션(Inflation)]] · [[WoW 토큰 및 PLEX]] · [[자원 로지스틱스(Resource Logistics)]] · [[위험과 보상 구조(Structures of Risks and Rewards)]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/가상 화폐 (Virtual Currency).md
+34
View File
@@ -0,0 +1,34 @@
---
id: wiki-2026-0508-가상-화폐-virtual-currency
title: 가상 화폐 (Virtual Currency)
category: 10_Wiki/Topics
status: duplicate
canonical_id: wiki-2026-0508-virtual-currency-canonical
duplicate_of: "[[Virtual-Currency]]"
aliases: [Virtual Currency, In-Game Currency]
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, virtual-currency, game-economy]
last_reinforced: 2026-05-10
github_commit: pending
---
# 가상 화폐 (Virtual Currency)
> **이 문서는 [[Virtual-Currency]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (specialization aspects)
- 매 게임 내부 거래 medium — Soft / Hard / Premium tier 분리.
- Faucet 으로 발행, Sink 로 소각 — 통화량 관리가 인플레이션 통제 의 core.
- Premium-Soft bridge 가 monetization conversion funnel 의 critical step.
## 🔗 Graph
- 부모: [[Virtual-Currency]] (canonical)
- 관련: [[프리미엄 통화 브릿지(Premium Currency Bridge)]] · [[다중 통화 시스템(Multi-Currency System)]] · [[가상 경제 인플레이션]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/경제 밸런싱(Economic Balancing).md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-경제-밸런싱-economic-balancing
title: 경제 밸런싱(Economic Balancing)
category: 10_Wiki/Topics
status: duplicate
canonical_id: economic-balancing
duplicate_of: "[[Economic Balancing]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, game-design, balancing]
last_reinforced: 2026-05-10
github_commit: pending
---
# 경제 밸런싱(Economic Balancing)
> **이 문서는 [[Economic Balancing]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- Faucet (재화 유입) ↔ Sink (재화 소모) 의 equilibrium 유지.
- Inflation 방어 — 누적 재화 가 가치 하락 야기 시 sink 증강.
- Telemetry 기반 econ tuning — 매 patch 의 유저 spending pattern 분석.
## 🔗 Graph
- Adjacent: [[수도꼭지(Faucets)]] · [[Telemetry]] · [[Virtual Currency]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/관리자 상점(Admin Shop).md
+34
View File
@@ -0,0 +1,34 @@
---
id: wiki-2026-0508-관리자-상점-admin-shop
title: 관리자 상점(Admin Shop)
category: 10_Wiki/Topics
status: duplicate
canonical_id: wiki-2026-0508-admin-shop-canonical
duplicate_of: "[[Admin-Shop]]"
aliases: [Admin Shop, NPC Shop, Sink Vendor]
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, game-economy, admin-shop, sink]
last_reinforced: 2026-05-10
github_commit: pending
---
# 관리자 상점(Admin Shop)
> **이 문서는 [[Admin-Shop]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (specialization aspects)
- 매 NPC-vendor 형식 의 currency Sink — 고정 가격 의 buy/sell 채널.
- Player-to-Player market 의 floor / ceiling 역할로 가격 anchor.
- Soft sink 또는 Hard sink 로 tuning, hyperinflation 방지 의 lever.
## 🔗 Graph
- 부모: [[Admin-Shop]] (canonical)
- 관련: [[수도꼭지와 배수구(Faucets and Sinks)]] · [[하드 싱크(Hard Sinks)]] · [[소프트 싱크(Soft Sinks)]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/데이터 기반 설계.md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-데이터-기반-설계
title: 데이터 기반 설계 (Data-Driven Design)
category: 10_Wiki/Topics
status: duplicate
canonical_id: data-driven-design
duplicate_of: "[[Data-Driven Design]]"
aliases: [DDD-data, 데이터 주도 설계]
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, architecture, game-design]
last_reinforced: 2026-05-10
github_commit: pending
---
# 데이터 기반 설계 (Data-Driven Design)
> **이 문서는 [[Data-Driven Design]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- Logic 과 data 의 분리 — config / table / asset 으로 behavior 정의.
- Designer-friendly iteration — 매 code recompile 없이 balance 조정.
- ECS, scriptable object, JSON/YAML config 의 implementation pattern.
## 🔗 Graph
- Adjacent: [[bitECS와 SharedArrayBuffer를 결합한 멀티스레드 고성능 아키텍처]] · [[Telemetry]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/디버거_Debugger.md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-디버거-debugger
title: 디버거 (Debugger)
category: 10_Wiki/Topics
status: duplicate
canonical_id: debugger
duplicate_of: "[[Debugger]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, tooling, debugging]
last_reinforced: 2026-05-10
github_commit: pending
---
# 디버거 (Debugger)
> **이 문서는 [[Debugger]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- Breakpoint, step-through, watch, call stack — 매 매 standard primitive.
- Modern: Chrome DevTools, VS Code DAP, lldb/gdb, time-travel debug (rr, replay.io).
- Production debug: source-map, remote debug protocol (CDP), structured logging.
## 🔗 Graph
- Adjacent: [[Chrome DevTools(크롬 개발자 도구)]] · [[Stack trace]] · [[Flame Chart]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/리그 오브 레전드(League of Legends).md
+34
View File
@@ -0,0 +1,34 @@
---
id: wiki-2026-0508-리그-오브-레전드-league-of-legends
title: 리그 오브 레전드(League of Legends)
category: 10_Wiki/Topics
status: duplicate
canonical_id: wiki-2026-0508-moba-game-design
duplicate_of: "[[MOBA Game Design]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, moba, league-of-legends, esports]
last_reinforced: 2026-05-10
github_commit: pending
---
# 리그 오브 레전드(League of Legends)
> **이 문서는 [[MOBA Game Design]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (LoL-specific aspects)
- **Riot Games**, 2009 launch — 매 DotA Allstars 의 standalone 진화. 매 free-to-play + champion skin monetization 의 정의.
- **Tech**: 매 자체 client (C++), Hextech matchmaking (modified Glicko-2), Vanguard anti-cheat (2024 글로벌).
- **Esports**: LCK, LPL, LEC, LCS — 매 World Championship 매년 1회. 매 viewership 단일 esports 1위.
- **Champion roster**: 매 170+ (2026 기준) — 매 ~6주 cadence patch.
- **Spinoffs**: Teamfight Tactics (auto-battler), Wild Rift (모바일), Arcane (Netflix), 2XKO (격투).
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/리더보드(Leaderboards).md
+31
View File
@@ -0,0 +1,31 @@
---
id: wiki-2026-0508-리더보드-leaderboards
title: 리더보드(Leaderboards)
category: 10_Wiki/Topics
status: duplicate
canonical_id: leaderboards
duplicate_of: "[[Leaderboards]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, game-design, social]
last_reinforced: 2026-05-10
github_commit: pending
---
# 리더보드(Leaderboards)
> **이 문서는 [[Leaderboards]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- 경쟁 시스템 (global, friend, segmented tiers).
- Engagement driver + retention 도구.
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/메타 레이어 (Meta Layers).md
+34
View File
@@ -0,0 +1,34 @@
---
id: wiki-2026-0508-메타-레이어-meta-layers
title: 메타 레이어 (Meta Layers)
category: 10_Wiki/Topics
status: duplicate
canonical_id: meta-layers
duplicate_of: "[[Meta Layers]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, game-design, meta-game, systems]
last_reinforced: 2026-05-10
github_commit: pending
---
# 메타 레이어 (Meta Layers)
> **이 문서는 [[Meta Layers]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (specialization aspects)
- 매 meta layer: core gameplay loop 위에 매 stacked progression/strategy systems — 매 long-term engagement 의 driver.
- 매 examples: MMO seasons/expansions, MOBA patch meta, roguelike unlock trees, gacha banner rotations.
- 매 design tension: meta refresh frequency ↔ player burnout, depth ↔ accessibility for new players.
- 매 2026 trend: AI-generated dynamic meta (procedural balance shifts), live-ops-driven micro-metas.
## 🔗 Graph
- 관련: [[LiveOps]] · [[Player Retention]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/모딩 생태계.md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-모딩-생태계
title: 모딩 생태계 (Modding Ecosystem)
category: 10_Wiki/Topics
status: duplicate
canonical_id: modding-ecosystem
duplicate_of: "[[Modding Ecosystem]]"
aliases: [모드, mod community]
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, game-design, community]
last_reinforced: 2026-05-10
github_commit: pending
---
# 모딩 생태계 (Modding Ecosystem)
> **이 문서는 [[Modding Ecosystem]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- User-generated content (UGC) 의 platform — game longevity 의 핵심 lever (Skyrim, Minecraft, Valheim).
- Mod API + workshop (Steam Workshop, Nexus Mods, mod.io) 의 분배 infra.
- Revenue-share + curation policy 의 균형 — paid mod 의 ethical concern.
## 🔗 Graph
- Adjacent: [[Platform Resistance]] · [[Hybrid Monetization]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/모바일 퍼스트 인덱싱(Mobile-First Indexing).md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-모바일-퍼스트-인덱싱-mobile-first-indexin
title: 모바일 퍼스트 인덱싱(Mobile-First Indexing)
category: 10_Wiki/Topics
status: duplicate
canonical_id: mobile-first-indexing
duplicate_of: "[[Mobile-First Indexing]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, seo, web]
last_reinforced: 2026-05-10
github_commit: pending
---
# 모바일 퍼스트 인덱싱(Mobile-First Indexing)
> **이 문서는 [[Mobile-First Indexing]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- Google 의 mobile 버전 사이트를 primary index source 로 사용 (2023 부터 default).
- Mobile UX / Core Web Vitals (LCP, INP, CLS) 가 ranking 핵심 요소.
- Responsive design + 동일 content (mobile = desktop) 가 권장 pattern.
## 🔗 Graph
- Adjacent: [[Core Web Vitals Optimization (INP, LCP, CLS)|Cumulative Layout Shift (CLS)]] · [[Core Web Vitals Optimization (INP, LCP, CLS)|Core Web Vitals]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/부대 편성(Platoon Formations).md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-부대-편성-platoon-formations
title: 부대 편성(Platoon Formations)
category: 10_Wiki/Topics
status: duplicate
canonical_id: platoon-formations
duplicate_of: "[[Platoon Formations]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, strategy, game-design]
last_reinforced: 2026-05-10
github_commit: pending
---
# 부대 편성(Platoon Formations)
> **이 문서는 [[Platoon Formations]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- Strategy game 의 unit composition / arrangement 의 핵심 mechanic.
- Triangle (counter-pick) / line / wedge / column 의 standard formation 의 trade-off.
- Counter-formation matrix 의 RPS-style balancing.
## 🔗 Graph
- Adjacent: [[4X 전략]] · [[10v10 대규모 멀티플레이어]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/소음 역학 (Noise Dynamics).md
+31
View File
@@ -0,0 +1,31 @@
---
id: wiki-2026-0508-소음-역학-noise-dynamics
title: 소음 역학 (Noise Dynamics)
category: 10_Wiki/Topics
status: duplicate
canonical_id: noise-dynamics
duplicate_of: "[[Noise Dynamics]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, game-design, balancing]
last_reinforced: 2026-05-10
github_commit: pending
---
# 소음 역학 (Noise Dynamics)
> **이 문서는 [[Noise Dynamics]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- 게임 시스템에서 의도된 무작위성/변동성 (intentional variance).
- 예측가능성과 surprise 의 균형.
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/소프트 싱크(Soft Sinks).md
+31
View File
@@ -0,0 +1,31 @@
---
id: wiki-2026-0508-소프트-싱크-soft-sinks
title: 소프트 싱크(Soft Sinks)
category: 10_Wiki/Topics
status: duplicate
canonical_id: soft-sinks
duplicate_of: "[[Soft Sinks]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, game-economy, balancing]
last_reinforced: 2026-05-10
github_commit: pending
---
# 소프트 싱크(Soft Sinks)
> **이 문서는 [[Soft Sinks]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- 게임 경제에서 선택적 currency drain (cosmetics, convenience).
- Hard sinks 와 대비 — player choice 보존.
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/수도꼭지(Faucets).md
+34
View File
@@ -0,0 +1,34 @@
---
id: wiki-2026-0508-수도꼭지-faucets
title: 수도꼭지(Faucets)
category: 10_Wiki/Topics
status: duplicate
canonical_id: faucets
duplicate_of: "[[탭과_싱크(Taps_and_Sinks)|Faucets and Sinks]]"
aliases: [재화 유입, faucet]
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, game-economy, balancing]
last_reinforced: 2026-05-10
github_commit: pending
---
# 수도꼭지(Faucets)
> **이 문서는 [[탭과_싱크(Taps_and_Sinks)|Faucets and Sinks]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- Faucet — economy 에 재화 의 inflow source (quest reward, drop, daily login).
- Sink 와 pair 의 equilibrium — faucet > sink 시 inflation, faucet < sink 시 deflation.
- Tuning 의 핵심 — 매 player tier 의 faucet rate 의 progression curve.
## 🔗 Graph
- 부모: [[탭과_싱크(Taps_and_Sinks)|Faucets and Sinks]] (canonical)
- Adjacent: [[경제 밸런싱(Economic Balancing)]] · [[Virtual Currency]] · [[ARPU-ARPPU]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/수도꼭지와 배수구(Faucets and Sinks).md
+34
View File
@@ -0,0 +1,34 @@
---
id: wiki-2026-0508-수도꼭지와-배수구-faucets-and-sinks
title: 수도꼭지와 배수구(Faucets and Sinks)
category: 10_Wiki/Topics
status: duplicate
canonical_id: faucets-and-sinks
duplicate_of: "[[탭과_싱크(Taps_and_Sinks)|Faucets and Sinks]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, game-economy, virtual-economy]
last_reinforced: 2026-05-10
github_commit: pending
---
# 수도꼭지와 배수구(Faucets and Sinks)
> **이 문서는 [[탭과_싱크(Taps_and_Sinks)|Faucets and Sinks]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (Korean specialization)
- Faucet (유입) + Sink (유출) — 가상 경제 디자인의 핵심 dual 메커니즘.
- Faucet 예: 퀘스트 보상, 드롭, 일일 로그인. Sink 예: 수리비, 거래 수수료, 영구 소비 아이템.
- Net flow > 0 → 인플레이션 (재화 가치 하락). Net flow < 0 → 디플레이션 (premature paywalls).
## 🔗 Graph
- 부모: [[탭과_싱크(Taps_and_Sinks)|Faucets and Sinks]] (canonical)
- 관련: [[Monetization (BM)]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — Faucets and Sinks 로 redirect |
10_Wiki/Topics/Domain_General/From_Other/아크 2 테크놀로지 및 유닛(Arc 2 Technology and Units).md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-아크-2-테크놀로지-및-유닛-arc-2-technology
title: 아크 2 테크놀로지 및 유닛(Arc 2 Technology and Units)
category: 10_Wiki/Topics
status: duplicate
canonical_id: warno-arc-2
duplicate_of: "[[WARNO Arc 2]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, warno, rts, tech-tree]
last_reinforced: 2026-05-10
github_commit: pending
---
# 아크 2 테크놀로지 및 유닛(Arc 2 Technology and Units)
> **이 문서는 [[WARNO Arc 2]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (Korean specialization)
- WARNO Arc 2 — 1989 시나리오 확장 테크 트리 + 신규 유닛 lineup.
- Soviet, NATO 양 진영의 "what-if" 차세대 장비 (T-80UM, M1A2, Tornado IDS late-block).
- 기존 Arc 1 대비 unit cost 인플레이션 + 카운터 메타 변경.
## 🔗 Graph
- 관련: [[Eugen Systems 모딩 매뉴얼]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — WARNO Arc 2 로 redirect |
10_Wiki/Topics/Domain_General/From_Other/악명(Infamy) 시스템.md
+32
View File
@@ -0,0 +1,32 @@
---
id: wiki-2026-0508-악명-infamy-시스템
title: 악명(Infamy) 시스템
category: 10_Wiki/Topics
status: duplicate
canonical_id: infamy-system
duplicate_of: "[[Infamy System]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, game-design, reputation, mechanics]
last_reinforced: 2026-05-10
github_commit: pending
---
# 악명(Infamy) 시스템
> **이 문서는 [[Infamy System]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (Korean specialization)
- Infamy — 플레이어 부정적 행동을 누적해 NPC reaction, 가격, 추격 등에 영향.
- GTA, RDR, Skyrim Bounty, Payday 의 heat level 계열 메커니즘.
- 회복 path: 시간 경과, bribe, 특정 quest, faction shift.
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — Infamy System 로 redirect |
10_Wiki/Topics/Domain_General/From_Other/연속 승리 이벤트(Streak events).md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-연속-승리-이벤트-streak-events
title: 연속 승리 이벤트(Streak events)
category: 10_Wiki/Topics
status: duplicate
canonical_id: streak-events
duplicate_of: "[[Streak Events]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, live-ops, engagement, retention]
last_reinforced: 2026-05-10
github_commit: pending
---
# 연속 승리 이벤트(Streak events)
> **이 문서는 [[Streak Events]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (Korean specialization)
- Streak — 연속 N일 / N승 달성 시 누적 보상 unlock.
- 변동 보상 schedule (variable ratio) 효과로 retention 상승.
- Risk: streak break 시 churn trigger — recovery (streak freeze) 메커니즘 권장.
## 🔗 Graph
- 관련: [[LiveOps]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — Streak Events 로 redirect |
10_Wiki/Topics/Domain_General/From_Other/위험과 보상 구조(Structures of Risks and Rewards).md
+191
View File
@@ -0,0 +1,191 @@
---
id: wiki-2026-0508-위험과-보상-구조-structures-of-risks-an
title: 위험과 보상 구조(Structures of Risks and Rewards)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [R&R Structures, Risk-Reward Patterns, 위험보상 패턴]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-design, encounter-design, structures, patterns]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: typescript
framework: unity-csharp
---
# 위험과 보상 구조(Structures of Risks and Rewards)
## 매 한 줄
> **"매 R&R curve 매 abstract — 매 structure 매 concrete encounter shape"**. 매 [[위험과 보상(Risks and Rewards)]] 매 principle, 매 이 문서 매 player 의 의 hand 의 의 의 매 actual concrete pattern (gauntlet, fork, escalator, sandbox, push-your-luck) 의 catalog.
## 매 핵심
### 매 8 canonical structures
1. **매 Fork**: 매 safe path vs risky path 매 simultaneous offer.
2. **매 Gauntlet**: 매 escalating difficulty 매 reward 매 cumulative.
3. **매 Push-your-luck**: 매 stop / continue 매 explicit player choice.
4. **매 Sandbox / pick-your-stakes**: 매 player 매 difficulty modifier 의 pre-select.
5. **매 Investment**: 매 upfront cost (resource / time) 의 future return 매 trade.
6. **매 Bluff / commit**: 매 hidden information 매 reveal 매 risk.
7. **매 Time pressure**: 매 fast-but-risky vs slow-but-safe.
8. **매 Wager**: 매 player 매 reward 의 size 의 dial.
### 매 structure selection axes
- **explicit vs emergent**: 매 player 매 risk 의 conscious choice 매 가능?
- **front-loaded vs back-loaded**: 매 risk 매 paid upfront 매 / 매 outcome 의 reveal 매 시?
- **bounded vs unbounded escalation**: 매 ceiling 매 존재?
- **reversible vs commit**: 매 mid-encounter back-out 매 가능?
### 매 응용
1. 매 Slay the Spire elite encounter = Fork (skip vs fight).
2. 매 Dead Cells 의 boss biome = Gauntlet (door choice + accumulated curse).
3. 매 Balatro 의 stake selection = Sandbox.
4. 매 Hades 의 boon rarity gamble = Push-your-luck (use coin reroll).
5. 매 Tarkov raid timer = Time pressure.
## 💻 패턴
### Fork structure
```typescript
type Path = { name: string; difficulty: number; reward: Reward };
type Reward = { gold: number; item?: string; rare?: boolean };
class Fork {
paths: Path[];
pick(idx: number): Reward {
const p = this.paths[idx];
return this.resolve(p);
}
resolve(p: Path): Reward {
const success = Math.random() > p.difficulty * 0.5;
return success ? p.reward : { gold: 0 };
}
}
const fork = new Fork();
fork.paths = [
{ name: "safe", difficulty: 0.2, reward: { gold: 50 } },
{ name: "risky", difficulty: 0.7, reward: { gold: 250, rare: true } },
];
```
### Gauntlet (escalating)
```typescript
class Gauntlet {
rooms: number;
cumulativeReward = 0;
cumulativeDamage = 0;
step(roomIdx: number) {
const difficulty = 1 + roomIdx * 0.3;
const damage = Math.random() * difficulty * 10;
const reward = 50 * Math.pow(1.4, roomIdx);
this.cumulativeDamage += damage;
this.cumulativeReward += reward;
return { reward, damage, total: this.cumulativeReward };
}
}
```
### Push-your-luck
```typescript
class PushYourLuck {
pot = 100;
bustP = 0.1;
step() {
this.bustP += 0.08;
if (Math.random() < this.bustP) {
return { state: "BUST", payout: 0 };
}
this.pot *= 1.5;
return { state: "CONTINUE", pot: this.pot, bustP: this.bustP };
}
cashOut() { return { state: "CASHED", payout: this.pot }; }
}
```
### Sandbox (pre-select stakes)
```csharp
public class StakeConfig {
public List<string> Modifiers = new();
public int RewardMultiplier = 1;
}
public class StakePicker {
public StakeConfig Build(List<string> picked) {
return new StakeConfig {
Modifiers = picked,
RewardMultiplier = 1 + picked.Count
};
}
}
// Player commits BEFORE encounter; no mid-fight escape
```
### Investment structure
```typescript
class Investment {
spend(amount: number, projectId: string): Promise<number> {
// Resource committed now; outcome resolves later
return new Promise(resolve => {
const success = Math.random() < 0.6;
const payout = success ? amount * 2.5 : 0;
setTimeout(() => resolve(payout), 5000); // delayed reveal
});
}
}
```
### Time pressure
```typescript
class TimedRaid {
start = Date.now();
loot = 0;
loop() {
const elapsed = (Date.now() - this.start) / 1000;
const extractRisk = Math.min(0.05 + elapsed * 0.01, 0.9);
// Each tick: more loot, but rising chance of PvP encounter
this.loot += 10;
return { loot: this.loot, extractRisk };
}
}
```
## 매 결정 기준
| 상황 | 적합 structure |
|---|---|
| 매 quick decision moment | Fork |
| 매 sustained tension session | Gauntlet |
| 매 explicit gambling feel | Push-your-luck |
| 매 customizable difficulty | Sandbox |
| 매 strategic depth | Investment |
| 매 PvP / multiplayer | Bluff, Time pressure |
**기본값**: 매 game type 의 의 의 1-2 structure 매 main + 매 1 secondary 의 layer.
## 🔗 Graph
- 부모: [[위험과 보상(Risks and Rewards)]]
- 응용: [[핀치 포인트(Pinch Point)]] · [[Boss Design]]
- Adjacent: [[Choice Architecture]] · [[Decision Theory]]
## 🤖 LLM 활용
**언제**: 매 specific encounter / room / level 의 design 시 매 concrete pattern 의 select.
**언제 X**: 매 high-level economy 의 의 design — 매 [[위험과 보상(Risks and Rewards)]] 의 의 abstract level 의 의 사용.
## ❌ 안티패턴
- **매 single structure overuse**: 매 모든 encounter 매 same pattern → 매 fatigue.
- **매 commit without information**: 매 sandbox stake 매 picker 매 modifier effect 매 unknown 시 매 frustrating.
- **매 false fork**: 매 Fork 매 path 매 EV 매 동일 시 매 meaningless choice.
## 🧪 검증 / 중복
- Verified (Schell, Costikyan *Uncertainty in Games*, GDC talks on roguelike encounter design).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — 8 canonical structures + working code per structure |
10_Wiki/Topics/Domain_General/From_Other/위험과 보상(Risks and Rewards).md
+172
View File
@@ -0,0 +1,172 @@
---
id: wiki-2026-0508-위험과-보상-risks-and-rewards
title: 위험과 보상(Risks and Rewards)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Risk-Reward, R&R Curve, 리스크 리워드]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-design, economy, risk-reward, decision-making]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: typescript
framework: unity-csharp
---
# 위험과 보상(Risks and Rewards)
## 매 한 줄
> **"매 player choice 매 risk-reward tension 의 산물"**. 매 1980s arcade era (Pac-Man power pellet hunt, Galaga fighter capture) 부터 매 2026 modern roguelite (Hades heat system, Balatro stake escalation) 까지 매 동일한 design pillar 의 작동 — 매 player 에게 매 "더 큰 reward 의 위해 매 더 큰 risk 매 감수할 것인가?" 의 매 질문 의 제시.
## 매 핵심
### 매 R&R curve shape
- **매 linear**: risk 2배 = reward 2배. 매 보장적 매 boring.
- **매 convex (accelerating)**: risk 2배 = reward 4배+. 매 high-skill push 매 보상.
- **매 concave (diminishing)**: risk 2배 = reward 1.3배. 매 conservative play 매 우대.
- **매 step function**: threshold 매 도달 시 매 jump. 매 commitment 매 design.
### 매 expected value (EV) framework
- EV = Σ(outcome × probability)
- 매 design goal: 매 EV(risky) > EV(safe) by ~10-20% 매. 매 너무 크면 매 risk 매 obvious choice. 매 너무 작으면 매 risk 매 trap.
- 매 variance 매 player perception 의 영향 — 매 same EV 라도 매 high-variance 매 더 위험적 매 felt.
### 매 응용
1. 매 Hades heat: +1 heat = run 의 +X% 의 어려움, +Y% 의 reward bonus. 매 player chooses pace.
2. 매 Balatro stake: ante 매 escalation curve 매 explicit risk dial.
3. 매 Diablo 4 Pit tier: timer 매 압박 의 high-tier 매 push 시 매 huge loot.
4. 매 PoE Atlas: map mods (more rare/magic) 매 increase difficulty + drop quality.
5. 매 Tarkov raid: extract early (safe loot) vs hunt boss (rare items, PvP risk).
## 💻 패턴
### Linear vs convex reward curve
```typescript
// Linear: predictable, low excitement
const linearReward = (risk: number) => 100 * risk;
// Convex: high-skill players get exponential reward
const convexReward = (risk: number) => 100 * Math.pow(risk, 1.6);
// Concave: protect casual players from punishment-snowball
const concaveReward = (risk: number) => 100 * Math.pow(risk, 0.7);
// Step: clear "go/no-go" decisions
const stepReward = (risk: number) =>
risk < 0.3 ? 50 : risk < 0.7 ? 200 : 1000;
```
### Expected value calculator
```typescript
type Outcome = { value: number; probability: number };
function expectedValue(outcomes: Outcome[]): number {
return outcomes.reduce((sum, o) => sum + o.value * o.probability, 0);
}
// Design check: risky path should EV-dominate by 10-20%
const safe: Outcome[] = [{ value: 100, probability: 1.0 }];
const risky: Outcome[] = [
{ value: 300, probability: 0.4 },
{ value: 0, probability: 0.6 },
];
console.log(expectedValue(safe)); // 100
console.log(expectedValue(risky)); // 120 — 20% premium for variance
```
### Variance-aware reward
```typescript
// Risk-averse player simulation: subtract σ * λ from EV
function utility(outcomes: Outcome[], lambda = 0.3): number {
const ev = expectedValue(outcomes);
const variance = outcomes.reduce(
(s, o) => s + o.probability * (o.value - ev) ** 2, 0
);
return ev - lambda * Math.sqrt(variance);
}
```
### Hades heat system pattern
```csharp
public class HeatModifier {
public string Name;
public float DifficultyDelta; // +0.15 enemy HP
public float RewardMultiplier; // +0.10 darkness
}
public class RunConfig {
public List<HeatModifier> Active = new();
public float TotalReward => 1f + Active.Sum(h => h.RewardMultiplier);
public float TotalDifficulty => 1f + Active.Sum(h => h.DifficultyDelta);
// Player picks which axis to dial: more enemies vs tougher boss vs less heal
}
```
### Push-your-luck (Balatro/Slay the Spire elite)
```typescript
class PushYourLuck {
pot = 0;
rounds = 0;
bustChance = 0.15;
step() {
this.rounds++;
this.bustChance += 0.05; // escalating
if (Math.random() < this.bustChance) return { result: "bust", payout: 0 };
this.pot += 100 * Math.pow(1.4, this.rounds);
return { result: "continue", pot: this.pot };
}
cashOut() { return { result: "cashed", payout: this.pot }; }
}
```
### Asymmetric punishment (Tarkov-style)
```typescript
// Death = lose carried gear; success = keep + bonus
function raidOutcome(survived: boolean, lootValue: number, gearValue: number) {
return survived ? { net: lootValue } : { net: -gearValue };
}
// Design: gearValue ≈ 0.5 * expected lootValue (so EV stays positive but tense)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 player skill 매 wide range | concave curve (cap snowball) |
| 매 high-skill audience (roguelike vet) | convex curve |
| 매 binary commit decisions | step function |
| 매 short session loop | step (clear payoff) |
| 매 long session escalation | continuous + variance |
**기본값**: 매 mildly convex (exponent ~1.3-1.5) + 매 EV premium 매 15% 매 risky path 의 매 적용.
## 🔗 Graph
- 부모: [[Game Economy]] · [[Decision Making]]
- 변형: [[위험과 보상 구조(Structures of Risks and Rewards)]]
- 응용: [[핀치 포인트(Pinch Point)]]
- Adjacent: [[Loss Aversion]]
## 🤖 LLM 활용
**언제**: 매 economy / progression / encounter 매 design 시 매 player choice tension 의 calibrate 시.
**언제 X**: 매 narrative-only 매 walking sim (no choice stakes) — 매 R&R framework 매 misapplied.
## ❌ 안티패턴
- **매 risk without reward**: 매 die 시 매 lose progress, 매 win 시 매 nothing extra. 매 player 매 leave.
- **매 reward without risk**: 매 free 의 grind 의 best gear. 매 boring.
- **매 hidden EV**: 매 player 매 calculate 의 X. 매 trap design (slot machine illusion) — 매 ethical 의 X.
- **매 binary cliff**: 매 EV jump 매 too sharp 매 → 매 only one viable path.
## 🧪 검증 / 중복
- Verified (Schell *Art of Game Design*, Adams *Fundamentals of Game Design*).
- 매 modern roguelite 매 case studies (Hades, Balatro, Slay the Spire).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — R&R curve types + EV framework + working code patterns |
10_Wiki/Topics/Domain_General/From_Other/은신과 시야 매커니즘 (Stealth and Optics).md
+32
View File
@@ -0,0 +1,32 @@
---
id: wiki-2026-0508-은신과-시야-매커니즘-stealth-and-optics
title: 은신과 시야 매커니즘 (Stealth and Optics)
category: 10_Wiki/Topics
status: duplicate
canonical_id: stealth-and-optics
duplicate_of: "[[Stealth-and-Optics]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, stealth, optics, game-systems]
last_reinforced: 2026-05-10
github_commit: pending
---
# 은신과 시야 매커니즘 (Stealth and Optics)
> **이 문서는 [[Stealth-and-Optics]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (Korean specialization)
- WARNO/Eugen RTS 컨텍스트의 한국어 번역본.
- Optics value vs concealment 원칙: 매 unit detection threshold 의 한국어 설명.
- LOS (Line of Sight) + cover modifier 의 한국어 명명.
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/인플레이션(Inflation).md
+35
View File
@@ -0,0 +1,35 @@
---
id: wiki-2026-0508-인플레이션-inflation
title: 인플레이션(Inflation)
category: 10_Wiki/Topics
status: duplicate
canonical_id: virtual-economy-inflation
duplicate_of: "[[Virtual Economy Inflation]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, virtual-economy, inflation, mmo-design]
last_reinforced: 2026-05-10
github_commit: pending
---
# 인플레이션(Inflation)
> **이 문서는 [[Virtual Economy Inflation]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (specialization aspects)
- 매 mechanism: faucet (mob gold drops, quest rewards) > sink (repair, AH tax, consumables) → 매 currency value decay.
- 매 indicators: top-tier item prices, raw mat 가격, gold-per-USD black market rate.
- 매 mitigations: increased sinks (cosmetic shops, housing upkeep), faucet nerfs, currency reset (new server / expansion).
- 매 historical: Diablo II rune ladder reset, WoW gold cap escalation, RuneScape Grand Exchange stabilization.
## 🔗 Graph
- 부모: [[Virtual Economy Inflation]] (canonical)
- 관련: [[가상 경제 시스템의 구조적 무결성 분석]] · [[WoW 토큰 및 PLEX]] · [[자원 로지스틱스(Resource Logistics)]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/자원 로지스틱스(Resource Logistics).md
+169
View File
@@ -0,0 +1,169 @@
---
id: wiki-2026-0508-자원-로지스틱스-resource-logistics
title: 자원 로지스틱스(Resource Logistics)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Resource Logistics, Supply Chain (Game), Resource Flow Design, 자원 흐름]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-design, economy, systems-design, factorio, rts]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: typescript
framework: ecs-bevy
---
# 자원 로지스틱스(Resource Logistics)
## 매 한 줄
> **"매 source → transport → buffer → consumer 매 chain 매 game 의 의 backbone"**. 매 *Factorio* (2016 → 2.0 Space Age 2024) 매 belt-bot-train 매 trinity, *Dyson Sphere Program* (2021), *Satisfactory* (1.0 2024) 매 매 매 동일한 design pillar — 매 player 매 logistics 의 의 의 의 의 의 problem 의 의 의 solving.
## 매 핵심
### 매 logistics primitives
1. **Source (생산)**: miner / extractor / spawn point.
2. **Transport (수송)**: belt, pipe, train, drone, teleport.
3. **Buffer (저장)**: chest, tank, warehouse.
4. **Consumer (소비)**: assembler, smelter, ship, player.
5. **Throttle / 제어**: priority splitter, circuit network, request gate.
### 매 transport 매 axis tradeoffs
- **belt**: cheap, infinite, slow, density-bound.
- **pipe**: fluid only, pressure-aware (DSP, Satisfactory 1.0).
- **train**: high-throughput, high-latency, expensive.
- **drone / bot**: flexible routing, energy-intensive.
- **teleport / portal**: 매 endgame, breaks classical logistics tension.
### 매 응용
1. *Factorio* main bus 의 vs city-block layout.
2. *Satisfactory* 의 train network + drone hops.
3. *Dyson Sphere Program* 의 logistics tower 의 interplanetary supply.
4. *Anno 1800* 의 trade route + warehouse.
5. *RimWorld* 의 stockpile priority + pawn hauling AI.
## 💻 패턴
### Belt throughput simulation
```typescript
interface BeltSegment {
capacity: number; // items / sec (Factorio yellow=15, red=30, blue=45)
current: number;
upstream?: BeltSegment;
}
function tickBelt(seg: BeltSegment, dt: number) {
const incoming = Math.min(seg.upstream?.current ?? 0, seg.capacity * dt);
seg.current += incoming;
if (seg.upstream) seg.upstream.current -= incoming;
// saturation = bottleneck visible to player
return { saturation: seg.current / (seg.capacity * dt) };
}
```
### Producer/consumer rate matching
```typescript
function balanceRatio(producerRate: number, consumerRate: number): number {
return producerRate / consumerRate;
// ratio = 1.0 → balanced
// < 1 → consumer starves (add producers)
// > 1 → buffer overflow (add consumers / storage)
}
// Factorio classic: 1 stone furnace = 0.3125 plate/s
// 1 yellow belt = 15 items/s → needs 48 furnaces to saturate
```
### Train scheduling (priority + fuel)
```typescript
type Station = { id: string; demand: number; supply: number };
function dispatchTrain(stations: Station[]): { from: string; to: string } | null {
const supplier = stations.filter(s => s.supply > 0)
.sort((a, b) => b.supply - a.supply)[0];
const consumer = stations.filter(s => s.demand > 0)
.sort((a, b) => b.demand - a.demand)[0];
if (!supplier || !consumer) return null;
return { from: supplier.id, to: consumer.id };
}
```
### Drone routing (cost-aware)
```typescript
function chooseDrone(drones: Drone[], from: Vec2, to: Vec2): Drone | null {
return drones
.filter(d => d.battery > distance(from, to) * d.energyPerTile)
.sort((a, b) => distance(a.pos, from) - distance(b.pos, from))[0];
}
```
### Stockpile priority (RimWorld-style)
```typescript
interface Stockpile {
id: string;
priority: 1 | 2 | 3 | 4 | 5; // 5 = highest
acceptedTags: string[];
capacity: number;
current: number;
}
function chooseStockpile(piles: Stockpile[], item: Item): Stockpile | null {
return piles
.filter(p => p.acceptedTags.includes(item.tag))
.filter(p => p.current < p.capacity)
.sort((a, b) => b.priority - a.priority)[0] ?? null;
}
```
### Bottleneck detector (ECS / Bevy-style pseudo)
```rust
// Bevy system that flags saturated belts for player visualization
fn detect_bottlenecks(
mut belts: Query<(&BeltSegment, &mut MaterialColor)>,
) {
for (belt, mut color) in &mut belts {
let sat = belt.current / belt.capacity;
color.0 = if sat > 0.95 { RED } else if sat > 0.7 { YELLOW } else { GREEN };
}
}
```
## 매 결정 기준
| 상황 | transport |
|---|---|
| 매 short distance, low rate | belt |
| 매 long distance, high rate | train |
| 매 fluid | pipe |
| 매 sparse / mobile target | drone |
| 매 cross-planet / cross-zone | logistics tower / portal |
**기본값**: 매 early-game belt → mid-game train → late-game drone+train hybrid → endgame logistics network.
## 🔗 Graph
- 부모: [[Game Economy]]
- 응용: [[프리미엄 통화 브릿지(Premium Currency Bridge)]]
- Adjacent: [[Operations Research]]
## 🤖 LLM 활용
**언제**: 매 factory builder / RTS / colony sim 매 design, 매 production-chain balance 의 의 system 의 build 시.
**언제 X**: 매 narrative-only / linear adventure — 매 logistics 매 systems-driven design 의 의 의 매 fit.
## ❌ 안티패턴
- **매 infinite buffer**: 매 buffer 매 size 매 ∞ 시 매 logistics tension 매 의 의 disappears.
- **매 zero friction**: 매 instant teleport 매 baseline → 매 layout 매 의 의 의 의 의 trivial.
- **매 over-coupled**: 매 single bottleneck 매 chain 의 의 의 의 의 cascade — 매 player frustration.
- **매 invisible bottleneck**: 매 saturation visualization 매 X → 매 player 매 의 의 root cause 의 의 의 X.
## 🧪 검증 / 중복
- Verified (Wube Software dev blogs Factorio FFF series, Coffee Stain Studios Satisfactory talks, GDC factory-builder 의 talks 2023-2025).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — logistics primitives + transport tradeoffs + working belt/train/drone code |
10_Wiki/Topics/Domain_General/From_Other/자원 보관 및 압축(Resource Storage & Compression).md
+32
View File
@@ -0,0 +1,32 @@
---
id: wiki-2026-0508-자원-보관-및-압축-resource-storage-comp
title: "자원 보관 및 압축(Resource Storage & Compression)"
category: 10_Wiki/Topics
status: duplicate
canonical_id: resource-storage-and-compression
duplicate_of: "[[Resource-Storage-and-Compression]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, resource-management, compression, economy]
last_reinforced: 2026-05-10
github_commit: pending
---
# 자원 보관 및 압축(Resource Storage & Compression)
> **이 문서는 [[Resource-Storage-and-Compression]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- Cap 제한 → 매 player resource hoarding 차단.
- Conversion rate (low-tier → high-tier) — sink + progress.
- Idle/builder game (Clash of Clans, Hay Day) 의 prototype 모델.
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/장갑 관통 모델링(Armor Penetration Modeling).md
+32
View File
@@ -0,0 +1,32 @@
---
id: wiki-2026-0508-장갑-관통-모델링-armor-penetration-mode
title: 장갑 관통 모델링(Armor Penetration Modeling)
category: 10_Wiki/Topics
status: duplicate
canonical_id: armor-penetration-modeling
duplicate_of: "[[Armor-Penetration-Modeling]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, armor, penetration, ballistics]
last_reinforced: 2026-05-10
github_commit: pending
---
# 장갑 관통 모델링(Armor Penetration Modeling)
> **이 문서는 [[Armor-Penetration-Modeling]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- 매 penetration vs armor 차이 → damage curve.
- Distance falloff: range tier 마다 -1 to -3 pen 감소.
- Eugen WARNO 와 World of Tanks 의 다른 모델 비교.
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/장갑 및 사거리 데이터 (Armor and Range Stats).md
+32
View File
@@ -0,0 +1,32 @@
---
id: wiki-2026-0508-장갑-및-사거리-데이터-armor-and-range-sta
title: 장갑 및 사거리 데이터 (Armor and Range Stats)
category: 10_Wiki/Topics
status: duplicate
canonical_id: armor-and-range-stats
duplicate_of: "[[Armor-and-Range-Stats]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, armor, range, stats, warno]
last_reinforced: 2026-05-10
github_commit: pending
---
# 장갑 및 사거리 데이터 (Armor and Range Stats)
> **이 문서는 [[Armor-and-Range-Stats]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- WARNO ndf armor (front/side/rear/top) + range tier 의 한국어 데이터 표.
- Engagement envelope: 매 weapon range vs sight range 의 의미.
- Armor 0-30 scale, range 700-3500m bracket.
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/콘텐츠 로테이션(Content Rotation).md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-콘텐츠-로테이션-content-rotation
title: 콘텐츠 로테이션(Content Rotation)
category: 10_Wiki/Topics
status: duplicate
canonical_id: content-rotation
duplicate_of: "[[Content-Rotation]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, content, rotation, liveops]
last_reinforced: 2026-05-10
github_commit: pending
---
# 콘텐츠 로테이션(Content Rotation)
> **이 문서는 [[Content-Rotation]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- Weekly/seasonal 콘텐츠 cycle — 매 player retention 의 lever.
- FOMO 압력: 매 limited-time event 의 효과.
- Fortnite/Apex/Clash Royale 의 prototype 모델.
## 🔗 Graph
- 인접: [[LiveOps]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/From_Other/클래시 로얄 라틴 아메리카 챔피언십.md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-클래시-로얄-라틴-아메리카-챔피언십
title: 클래시 로얄 라틴 아메리카 챔피언십
category: 10_Wiki/Topics
status: duplicate
canonical_id: clash-royale-latin-american-championship
duplicate_of: "[[Clash-Royale-Latin-American-Championship]]"
aliases: [CRL Latam]
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, esports, clash-royale, latam]
last_reinforced: 2026-05-10
github_commit: pending
---
# 클래시 로얄 라틴 아메리카 챔피언십
> **이 문서는 [[Clash-Royale-Latin-American-Championship]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- Supercell의 LATAM esports league — 지역 분기 토너먼트.
- 매 regional production 의 case study (broadcast, sponsorship, monetization).
- Mobile esports 의 prototype.
## 🔗 Graph
- 인접: [[클래시 로얄 모바일 게임 프로덕션]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |

Some files were not shown because too many files have changed in this diff Show More