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/General Knowledge/Brand-Identity-Management.md
+184
View File
@@ -0,0 +1,184 @@
---
id: wiki-2026-0508-brand-identity-management
title: Brand Identity Management
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [P-REINFORCE-AUTO-F8EDF9, Brand Identity, BI Management]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [branding, marketing, design-systems, identity]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: typescript
framework: figma-tokens
---
# Brand Identity Management
## 매 한 줄
> **"매 brand 의 systematic codification"**. 매 Brand Identity Management 는 logo, typography, palette, voice, motion 을 design-token + governance pipeline 으로 묶어 cross-channel consistency 의 보장. 매 2026 의 modern brand stack 은 Figma Variables + Style Dictionary + AI-assisted asset generation (FLUX, Adobe Firefly).
## 매 핵심
### 매 brand asset 분류
- **Visual**: logo, color palette, typography, iconography, photography style.
- **Verbal**: tone of voice, lexicon, naming convention.
- **Motion**: easing curves, timing, transition vocabulary.
- **Sonic**: audio logo, UI sounds.
### 매 governance layer
- **Design tokens**: 매 single source of truth (Figma Variables → Style Dictionary → CSS/iOS/Android).
- **Brand portal**: 매 self-service asset library (Frontify, Brandfolder).
- **Approval workflow**: 매 marketing automation 의 brand-safe template.
### 매 응용
1. Multi-product company 의 sub-brand 관리 (Atlassian Jira/Confluence/Trello).
2. Localization 의 culturally-adapted asset variant.
3. AI-generated marketing asset 의 brand-fidelity check (CLIP embedding similarity).
## 💻 패턴
### 패턴 1: Design Token 정의 (Style Dictionary)
```json
{
"color": {
"brand": {
"primary": { "value": "#FF6B35", "comment": "Antigravity Orange" },
"accent": { "value": "#1B1B1F" },
"surface": { "value": "#FAFAFA" }
}
},
"typography": {
"display": {
"value": {
"fontFamily": "Inter",
"fontWeight": 700,
"fontSize": "48px",
"lineHeight": 1.1
}
}
}
}
```
### 패턴 2: Token → Multi-platform output
```js
// style-dictionary.config.js
module.exports = {
source: ['tokens/**/*.json'],
platforms: {
css: { transformGroup: 'css', buildPath: 'dist/css/', files: [{ destination: 'tokens.css', format: 'css/variables' }] },
ios: { transformGroup: 'ios', buildPath: 'dist/ios/', files: [{ destination: 'Tokens.swift', format: 'ios-swift/class.swift' }] },
android:{ transformGroup: 'android',buildPath: 'dist/android/',files: [{ destination: 'tokens.xml', format: 'android/resources' }] }
}
};
```
### 패턴 3: Brand-fidelity check (CLIP)
```python
import torch
import clip
from PIL import Image
device = "cuda" if torch.cuda.is_available() else "cpu"
model, preprocess = clip.load("ViT-B/32", device=device)
BRAND_PROMPT = "Antigravity orange, minimal modern tech brand, geometric"
def brand_fidelity(image_path: str) -> float:
image = preprocess(Image.open(image_path)).unsqueeze(0).to(device)
text = clip.tokenize([BRAND_PROMPT]).to(device)
with torch.no_grad():
image_features = model.encode_image(image)
text_features = model.encode_text(text)
sim = torch.cosine_similarity(image_features, text_features).item()
return sim # > 0.28 → on-brand
```
### 패턴 4: AI-generated asset 의 brand guardrail
```python
from anthropic import Anthropic
client = Anthropic()
def critique_asset(asset_url: str, guidelines: str) -> dict:
response = client.messages.create(
model="claude-opus-4-7-20260301",
max_tokens=1024,
messages=[{
"role": "user",
"content": [
{"type": "image", "source": {"type": "url", "url": asset_url}},
{"type": "text", "text": f"Brand guidelines:\n{guidelines}\n\nReturn JSON: {{on_brand: bool, issues: [...], score: 0-1}}"}
]
}]
)
return response.content[0].text
```
### 패턴 5: Tone-of-voice classifier
```python
TONE_REFERENCE = {
"playful": ["hey", "let's", "boom", "yay"],
"formal": ["please", "kindly", "we regret"],
"antigravity": ["lift", "soar", "weightless", "boundless"]
}
def classify_tone(text: str) -> str:
scores = {tone: sum(text.lower().count(w) for w in words)
for tone, words in TONE_REFERENCE.items()}
return max(scores, key=scores.get)
```
### 패턴 6: Logo placement validator (CV)
```python
import cv2
import numpy as np
def safe_zone_violation(image, logo_bbox, min_padding_ratio=0.1):
h, w = image.shape[:2]
x, y, lw, lh = logo_bbox
pad_x = min_padding_ratio * w
pad_y = min_padding_ratio * h
return (x < pad_x or y < pad_y or
x + lw > w - pad_x or y + lh > h - pad_y)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Multi-platform consistency | Style Dictionary + Figma Variables |
| AI-asset workflow | CLIP fidelity gate + human review |
| Sub-brand 관리 | shared core tokens + brand-specific overrides |
| Rapid iteration startup | Figma Library only, defer token build |
| Enterprise compliance | Frontify/Brandfolder + approval workflow |
**기본값**: Figma Variables → Style Dictionary → CLIP gate. 매 token-first.
## 🔗 Graph
- 부모: [[Design Systems]] · [[Marketing]]
- Adjacent: [[Style Dictionary Pipelines|Style Dictionary]] · [[Figma Variables]] · [[CLIP]]
## 🤖 LLM 활용
**언제**: brand audit, tone consistency check, asset critique, copy generation 의 voice guardrail.
**언제 X**: 매 high-stakes legal trademark review — 매 lawyer 의 영역.
## ❌ 안티패턴
- **Token sprawl**: 매 ad-hoc 50+ color token. 매 semantic naming (primary/secondary) 으로 collapse.
- **Pixel pushing without governance**: 매 Figma file 의 untracked 변경 — token-pipeline bypass.
- **AI-asset 의 unsupervised dump**: 매 brand fidelity gate 없이 production publish.
## 🧪 검증 / 중복
- Verified (Style Dictionary docs, Figma Variables docs, Frontify case studies).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — substantive content + 2026 stack (CLIP gate, AI-asset workflow) |
10_Wiki/Topics/Domain_General/General Knowledge/Code Splitting Lazy Loading.md
+192
View File
@@ -0,0 +1,192 @@
---
id: wiki-2026-0508-code-splitting-lazy-loading
title: Code Splitting & Lazy Loading
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [P-REINFORCE-AUTO-B933B1, Code Splitting, Lazy Loading]
duplicate_of: none
source_trust_level: A
confidence_score: 0.95
verification_status: applied
tags: [web, performance, bundling, react, vite]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: typescript
framework: react+vite
---
# Code Splitting & Lazy Loading
## 매 한 줄
> **"매 ship-only-what-you-execute"**. 매 Code Splitting 은 single bundle 을 route/component-bound chunk 로 분할하여 initial JS payload 의 minimization. Lazy Loading 은 매 chunk 를 user-interaction 시점에 fetch. 매 2026 의 standard 는 Vite + React.lazy + dynamic import + RSC (React Server Components) hybrid.
## 매 핵심
### 매 split 차원
- **Route-based**: 매 page 의 lazy import — `/dashboard`, `/settings`.
- **Component-based**: 매 heavy widget (chart, code-editor) 의 deferred load.
- **Vendor split**: 매 third-party (React, lodash) 의 separate chunk → long-term cache.
- **Dynamic feature flag**: 매 A/B variant 의 gated import.
### 매 핵심 메커니즘
- **Dynamic `import()`**: 매 ES module spec — Promise 반환.
- **Bundler chunk splitting**: Webpack/Vite 의 `splitChunks` heuristic.
- **HTTP/2 push 의 deprecation**: 매 modern preload + modulepreload 로 대체.
- **Streaming SSR + RSC**: 매 chunk 의 server-streamed delivery.
### 매 응용
1. SaaS dashboard — `/admin` route 의 lazy chunk.
2. E-commerce — checkout flow 만 separate bundle.
3. Editor app (Notion-like) — markdown/code-editor lazy.
## 💻 패턴
### 패턴 1: React.lazy + Suspense
```tsx
import { lazy, Suspense } from "react";
import { Routes, Route } from "react-router-dom";
const Dashboard = lazy(() => import("./pages/Dashboard"));
const Settings = lazy(() => import("./pages/Settings"));
export function App() {
return (
<Suspense fallback={<Skeleton />}>
<Routes>
<Route path="/" element={<Home />} />
<Route path="/dashboard" element={<Dashboard />} />
<Route path="/settings" element={<Settings />} />
</Routes>
</Suspense>
);
}
```
### 패턴 2: Vite manual chunks
```ts
// vite.config.ts
import { defineConfig } from "vite";
export default defineConfig({
build: {
rollupOptions: {
output: {
manualChunks(id) {
if (id.includes("node_modules/react")) return "react-vendor";
if (id.includes("node_modules/@radix-ui")) return "radix";
if (id.includes("/src/charts/")) return "charts";
}
}
}
}
});
```
### 패턴 3: Preload on hover (intent-based prefetch)
```tsx
function NavLink({ to, children }: { to: string; children: React.ReactNode }) {
const prefetch = () => {
if (to === "/dashboard") import("./pages/Dashboard");
};
return <Link to={to} onMouseEnter={prefetch} onFocus={prefetch}>{children}</Link>;
}
```
### 패턴 4: Conditional dynamic import
```tsx
async function loadChart(type: "line" | "bar" | "heatmap") {
switch (type) {
case "line": return (await import("./charts/Line")).default;
case "bar": return (await import("./charts/Bar")).default;
case "heatmap": return (await import("./charts/Heatmap")).default;
}
}
```
### 패턴 5: React Server Component (RSC) split
```tsx
// app/dashboard/page.tsx (Next.js 15+)
import { Suspense } from "react";
import { HeavyChart } from "./HeavyChart"; // server component
export default function Page() {
return (
<>
<Header />
<Suspense fallback={<ChartSkeleton />}>
<HeavyChart /> {/* streamed independently */}
</Suspense>
</>
);
}
```
### 패턴 6: Bundle analyzer pipeline
```bash
# Vite + rollup-plugin-visualizer
npm i -D rollup-plugin-visualizer
```
```ts
import { visualizer } from "rollup-plugin-visualizer";
export default defineConfig({
plugins: [visualizer({ open: true, gzipSize: true })]
});
```
### 패턴 7: Module federation (micro-frontend)
```ts
// host vite.config.ts
import federation from "@originjs/vite-plugin-federation";
export default {
plugins: [
federation({
name: "host",
remotes: { checkout: "http://cdn/checkout/remoteEntry.js" },
shared: ["react", "react-dom"]
})
]
};
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Multi-page SPA | route-based React.lazy |
| Heavy single widget | component-level dynamic import |
| Multi-team monorepo | module federation |
| Server-rendered Next.js | RSC + Suspense streaming |
| Legacy Webpack 4 | upgrade to Vite/Webpack 5 first |
| Initial paint > 3s | bundle analyzer + manualChunks |
**기본값**: Vite + React.lazy(route) + intent-prefetch on hover.
## 🔗 Graph
- 부모: [[Web Performance]]
- 변형: [[Module Federation]]
- 응용: [[React Server Components — 경계 의식]]
- Adjacent: [[Vite]] · [[Rollup]] · [[esbuild]]
## 🤖 LLM 활용
**언제**: bundle analysis 의 chunk strategy 추천, lazy boundary 후보 식별, manualChunks rule 작성.
**언제 X**: 매 production runtime 의 dynamic decision — 매 bundler-time static analysis 의 영역.
## ❌ 안티패턴
- **Over-splitting**: 매 component 마다 lazy — 매 too many waterfalls. 매 100KB+ threshold.
- **Suspense boundary 의 미사용**: 매 React.lazy 의 fallback 없음 → throw.
- **Preload everything**: 매 idle prefetch 의 abuse — bandwidth waste.
- **Dynamic import in render**: 매 매 render 마다 import() 호출 → re-fetch.
## 🧪 검증 / 중복
- Verified (web.dev code-splitting docs, Vite docs, React.lazy spec, RFC#118).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — substantive content + 2026 stack (Vite, RSC, module federation) |
10_Wiki/Topics/Domain_General/General Knowledge/Description-Logics.md
+173
View File
@@ -0,0 +1,173 @@
---
id: wiki-2026-0508-description-logics
title: Description Logics
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [P-REINFORCE-AUTO-088907, DL, ALC, SROIQ]
duplicate_of: none
source_trust_level: A
confidence_score: 0.92
verification_status: applied
tags: [logic, knowledge-representation, ontology, owl, semantic-web]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: owlready2+hermit
---
# Description Logics
## 매 한 줄
> **"매 decidable fragment of first-order logic"**. 매 Description Logics (DL) 은 concept (class), role (property), individual 을 formal language 로 표현하여 ontology reasoning 의 mathematical foundation. 매 OWL 2 (Web Ontology Language) 는 SROIQ(D) DL 의 syntactic dialect — 매 2026 의 Knowledge Graph + LLM grounding 의 backbone.
## 매 핵심
### 매 DL family (expressivity)
- **AL** (Attributive Language): atomic concept, conjunction, universal restriction.
- **ALC**: AL + full negation. 매 baseline.
- **ALCN**: ALC + cardinality.
- **SHIQ**: + role hierarchy, inverse role, qualified cardinality.
- **SROIQ**: SHIQ + role chain, self-restriction, nominal — OWL 2 DL 의 base.
### 매 reasoning task
- **Subsumption**: C ⊑ D (concept inclusion).
- **Consistency**: ontology 의 모순 검증.
- **Instance check**: a ∈ C.
- **Classification**: 전체 concept hierarchy 의 compute.
- **Realization**: 매 individual 의 most-specific class.
### 매 응용
1. Biomedical ontology (SNOMED CT, GO) — drug-disease reasoning.
2. Knowledge graph 의 schema validation (Wikidata, Schema.org).
3. LLM grounding — RAG 의 ontology-constrained retrieval.
4. Configuration management — feature compatibility reasoning.
## 💻 패턴
### 패턴 1: ALC concept 정의 (Owlready2)
```python
from owlready2 import *
onto = get_ontology("http://example.org/family.owl")
with onto:
class Person(Thing): pass
class Parent(Person): pass
class hasChild(Person >> Person): pass
class Mother(Parent):
equivalent_to = [Parent & ~onto.search(is_a=onto.Male)[0]]
# ALC: Mother ≡ Parent ⊓ ¬Male
```
### 패턴 2: SROIQ role chain (grandparent)
```python
with onto:
class hasGrandchild(Person >> Person):
# role chain: hasChild ∘ hasChild ⊑ hasGrandchild
property_chain = [[hasChild, hasChild]]
```
### 패턴 3: Reasoner 실행 (HermiT)
```python
from owlready2 import sync_reasoner_hermit
with onto:
sync_reasoner_hermit(infer_property_values=True)
# inferred axioms inspect
for cls in onto.classes():
print(cls, "⊑", cls.is_a)
```
### 패턴 4: Tableau algorithm (mini ALC)
```python
def alc_satisfiable(concept, world=None):
"""Naive tableau for ALC C ⊓ ¬C unsatisfiability check."""
world = world or {"individuals": {}, "constraints": []}
if concept[0] == "AND":
for sub in concept[1:]:
if not alc_satisfiable(sub, world):
return False
return True
if concept[0] == "NOT":
atom = concept[1]
if ("ATOM", atom) in world["constraints"]:
return False # clash
world["constraints"].append(("NOT_ATOM", atom))
return True
if concept[0] == "ATOM":
if ("NOT_ATOM", concept[1]) in world["constraints"]:
return False
world["constraints"].append(("ATOM", concept[1]))
return True
# ∃R.C, ∀R.C handled by spawning fresh individual ...
```
### 패턴 5: SPARQL over OWL inference
```sparql
PREFIX owl: <http://www.w3.org/2002/07/owl#>
PREFIX : <http://example.org/family#>
SELECT ?gp ?gc WHERE {
?gp :hasGrandchild ?gc . # inferred via property_chain
}
```
### 패턴 6: LLM-grounded ontology query
```python
import anthropic
from owlready2 import get_ontology
client = anthropic.Anthropic()
onto = get_ontology("./family.owl").load()
def grounded_answer(question: str) -> str:
classes = [c.name for c in onto.classes()]
response = client.messages.create(
model="claude-opus-4-7-20260301",
max_tokens=512,
system=f"Use only these ontology classes: {classes}. Answer with class names.",
messages=[{"role": "user", "content": question}]
)
return response.content[0].text
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Web ontology / Linked Data | OWL 2 DL (SROIQ) + Protégé |
| Lightweight inference | OWL 2 EL (medical) or RL (rule-based) |
| Real-time reasoning | RDFS + custom rules (avoid full DL) |
| Research / proof-of-concept | ALC + custom tableau |
| Fact-heavy KG (Wikidata) | SHACL validation > full DL reasoning |
| LLM grounding | EL/RL profile + SPARQL |
**기본값**: OWL 2 EL (tractable PTIME) + HermiT/ELK reasoner.
## 🔗 Graph
- 부모: [[Logic]] · [[Knowledge Representation]]
- Adjacent: [[Knowledge-Graphs]]
## 🤖 LLM 활용
**언제**: ontology design review, axiom suggestion, SPARQL 생성, RAG 의 ontology-grounded prompt.
**언제 X**: 매 reasoning soundness 의 결정 — DL reasoner (HermiT, ELK) 의 영역. LLM 은 hint only.
## ❌ 안티패턴
- **Open-world misunderstanding**: 매 absent fact 가 false 라 가정 — DL 은 OWA (open world).
- **Unique Name Assumption 가정**: 매 individual a ≠ b 자동 아님 — `differentFrom` 명시 필요.
- **Undecidable extension**: 매 SROIQ 의 추가 expressivity (full datatype reasoning) → 결정불가.
- **Reasoner 없이 inference**: 매 axiom 만 작성 + 매 reasoner 미실행 → no inferred triples.
## 🧪 검증 / 중복
- Verified (Baader et al. "DL Handbook", W3C OWL 2 spec, Owlready2 docs).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — substantive content + 2026 stack (Owlready2, HermiT, LLM grounding) |
10_Wiki/Topics/Domain_General/General Knowledge/Dopamine Signaling.md
+159
View File
@@ -0,0 +1,159 @@
---
id: wiki-2026-0508-dopamine-signaling
title: Dopamine Signaling
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [P-REINFORCE-AUTO-C204E9, DA Signaling, RPE, Reward Prediction Error]
duplicate_of: none
source_trust_level: A
confidence_score: 0.92
verification_status: applied
tags: [neuroscience, reinforcement-learning, reward, addiction, RPE]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: numpy+gymnasium
---
# Dopamine Signaling
## 매 한 줄
> **"매 reward prediction error 의 neural currency"**. 매 Dopamine (DA) signaling 은 mesolimbic + nigrostriatal pathway 에서 phasic burst 로 actual − expected reward (RPE) 를 broadcast — 매 Schultz 1997 의 landmark finding 이 modern reinforcement learning + addiction model 의 bridge. 매 2026 의 frontier 는 multi-dimensional DA (D1/D2 receptor, axonal vs somatic, microcircuit) 의 dissection.
## 매 핵심
### 매 pathway
- **Mesolimbic** (VTA → NAc): 매 reward, motivation, addiction.
- **Mesocortical** (VTA → PFC): 매 cognition, working memory.
- **Nigrostriatal** (SNc → dorsal striatum): 매 motor learning, habit.
- **Tuberoinfundibular** (hypothalamus → pituitary): 매 prolactin inhibition.
### 매 RPE encoding
- **Phasic burst**: 매 unexpected reward → DA 의 firing rate ↑.
- **Phasic dip**: 매 omitted expected reward → firing 의 below-baseline.
- **CS-shift**: 매 conditioning 의 결과 — burst 의 reward 시점에서 cue 시점으로 shift.
- **Tonic level**: 매 background motivation, vigor.
### 매 receptor 타입
- **D1-like** (D1, D5): Gs-coupled, cAMP↑, direct pathway, "Go".
- **D2-like** (D2, D3, D4): Gi-coupled, cAMP↓, indirect pathway, "NoGo".
- **Asymmetric learning**: D1 의 positive RPE, D2 의 negative RPE.
### 매 응용
1. Reinforcement learning algorithm (TD-learning) 의 biological basis.
2. Parkinson's disease — SNc 의 dopaminergic neuron 손실.
3. Addiction — mesolimbic 의 hijacking.
4. Schizophrenia — mesocortical hypofunction + mesolimbic hyperfunction.
5. ADHD — DA reuptake 의 dysregulation.
## 💻 패턴
### 패턴 1: TD(0) RPE simulation
```python
import numpy as np
def td_zero(states, rewards, alpha=0.1, gamma=0.95, episodes=1000):
V = np.zeros(len(states))
rpe_log = []
for _ in range(episodes):
for t in range(len(states) - 1):
rpe = rewards[t] + gamma * V[t+1] - V[t]
V[t] += alpha * rpe
rpe_log.append((t, rpe))
return V, rpe_log
```
### 패턴 2: CS-US shift (Pavlovian)
```python
def conditioning(trials=200, cs_step=10, us_step=20, alpha=0.2, gamma=0.9):
"""RPE 가 US 에서 CS 시점으로 shift 하는지 확인."""
V = np.zeros(30)
history = []
for trial in range(trials):
r = np.zeros(30); r[us_step] = 1.0
for t in range(29):
rpe = r[t] + gamma * V[t+1] - V[t]
V[t] += alpha * rpe
if t in (cs_step, us_step):
history.append((trial, t, rpe))
return history # late trials: cs_step burst, us_step ≈ 0
```
### 패턴 3: D1/D2 asymmetric update
```python
def d1d2_update(weights, rpe, lr_d1=0.1, lr_d2=0.1):
"""positive RPE → D1 facilitation, negative → D2 facilitation."""
if rpe > 0:
weights["go"] += lr_d1 * rpe
else:
weights["nogo"] += lr_d2 * (-rpe)
return weights
```
### 패턴 4: Tonic-phasic interaction
```python
def vigor_modulated_action(action_values, tonic_da, beta=2.0):
"""Niv 2007: tonic DA → response rate."""
p = np.exp(beta * tonic_da * action_values)
return p / p.sum()
```
### 패턴 5: Distributional RPE (Dabney 2020 finding)
```python
import torch
import torch.nn.functional as F
class DistributionalDA(torch.nn.Module):
"""다양한 optimism 의 DA neuron population."""
def __init__(self, n_neurons=20):
super().__init__()
self.taus = torch.linspace(0.1, 0.9, n_neurons)
self.values = torch.nn.Parameter(torch.zeros(n_neurons))
def update(self, reward, lr=0.1):
delta = reward - self.values
# asymmetric update per neuron
with torch.no_grad():
self.values += lr * torch.where(
delta > 0, self.taus * delta, (1 - self.taus) * delta
)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Behavioral RL model | TD(λ) / Q-learning, scalar RPE |
| Asymmetric learning bias 모델 | D1/D2 dual-pathway |
| Vigor / response rate 모델 | tonic DA + beta scaling |
| Risk-sensitive / distributional | distributional RL (Dabney 2020) |
| Clinical Parkinson | SNc loss + L-DOPA pharmacology |
| Addiction model | mesolimbic phasic 의 hijack + tolerance |
**기본값**: TD(0) scalar RPE 의 baseline. 매 D1/D2 의 추가 시점은 asymmetric bias 가 핵심인 task.
## 🔗 Graph
- 부모: [[Reinforcement Learning]]
- 응용: [[Addiction]] · [[Reward Prediction Error]]
- Adjacent: [[TD-Learning]] · [[Actor-Critic]] · [[Distributional RL]]
## 🤖 LLM 활용
**언제**: literature review (RPE, distributional DA), modeling hypothesis generation, neurobiology + RL bridge 의 explanation.
**언제 X**: 매 clinical diagnosis / prescription — 매 neurologist 의 영역.
## ❌ 안티패턴
- **Scalar oversimplification**: 매 single RPE channel 가정 — distributional + multi-receptor reality 의 무시.
- **DA = pleasure 오해**: 매 DA 는 prediction error / motivation, hedonic experience 는 opioid system.
- **Human ↔ rodent extrapolation**: 매 microcircuit + receptor expression 의 species difference 의 무시.
## 🧪 검증 / 중복
- Verified (Schultz 1997 Science, Niv 2007, Dabney 2020 Nature, modern review Berke 2018).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — substantive content + distributional DA finding |
10_Wiki/Topics/Domain_General/General Knowledge/Iriszoom 엔진의 물리적 가시화.md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-iriszoom-엔진의-물리적-가시화
title: Iriszoom 엔진의 물리적 가시화
category: 10_Wiki/Topics
status: duplicate
canonical_id: iriszoom-engine
duplicate_of: "[[Iriszoom Engine]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, iriszoom, rendering]
last_reinforced: 2026-05-10
github_commit: pending
---
# Iriszoom 엔진의 물리적 가시화
> **이 문서는 [[Iriszoom Engine]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (specialization aspects)
- 매 Iriszoom 엔진의 물리 기반 렌더링 측면 — depth-of-field, lens distortion 의 가시화 pipeline.
- 매 PBR + iris-aperture simulation 의 합성.
## 🔗 Graph
- 부모: [[Iriszoom Engine]] (canonical)
- Adjacent: [[Physically Based Rendering]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/General Knowledge/Markov-Random-Fields.md
+177
View File
@@ -0,0 +1,177 @@
---
id: wiki-2026-0508-markov-random-fields
title: Markov Random Fields
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [MRF, Undirected Graphical Model, Markov Network, Gibbs Random Field]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [machine-learning, probability, graphical-model, vision, statistics]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: Python
framework: PyTorch/NetworkX
---
# Markov Random Fields
## 매 한 줄
> **"매 undirected graph 의 joint distribution — local Markov property 의 satisfy"**. 매 Bayes net 의 directed counterpart — 매 conditional independence 의 graph separation 으로 read. Hammersley–Clifford (1971) 의 Gibbs distribution 의 equivalence — 2026 매 image segmentation, CRF, energy-based model (EBM) 의 underlie.
## 매 핵심
### 매 정의
- **Graph** $G = (V, E)$, 매 node 의 random variable $X_v$.
- **Local Markov**: $X_v \perp X_{V \setminus N[v]} \mid X_{N(v)}$ — 매 node 의 neighbors 의 condition 시 의 rest 의 independent.
- **Hammersley–Clifford**: 매 strictly positive joint 의 매 Gibbs form $P(x) = \frac{1}{Z} \prod_{C \in \mathcal{C}} \psi_C(x_C)$ — 매 clique 의 product.
- **Partition function**: $Z = \sum_x \prod_C \psi_C(x_C)$ — 매 intractable in general.
### 매 inference
- **Exact**: tree (sum-product / belief propagation).
- **Loopy BP**: 매 approximate, 매 often works.
- **MCMC**: Gibbs sampling — 매 conditional 의 sample 매 cycle.
- **Variational**: mean-field — 매 factorized $q(x) = \prod_v q_v(x_v)$.
- **Graph cut**: 매 binary submodular — 매 exact min-cut.
### 매 응용
1. Image segmentation (foreground/background MRF).
2. Conditional Random Fields (CRF) — sequence labeling.
3. Stereo / depth estimation (smoothness prior).
4. Energy-based generative models (EBMs).
5. Statistical physics (Ising, Potts).
## 💻 패턴
### Ising model — Gibbs sampling
```python
import numpy as np
def ising_gibbs(N=64, beta=0.44, steps=10_000, h=0.0):
spins = np.random.choice([-1, 1], size=(N, N))
for _ in range(steps):
i, j = np.random.randint(N, size=2)
nb = (spins[(i+1)%N, j] + spins[(i-1)%N, j]
+ spins[i, (j+1)%N] + spins[i, (j-1)%N])
dE = 2 * spins[i, j] * (beta * nb + h)
if dE < 0 or np.random.random() < np.exp(-dE):
spins[i, j] *= -1
return spins
```
### Loopy belief propagation (binary pairwise)
```python
def loopy_bp(unary, pairwise, edges, iters=20):
# unary[v] : log-potential per node, shape (V, K)
# pairwise : (E, K, K) log-potentials
# edges : list of (u, v)
msg = {(u, v): np.zeros(unary.shape[1]) for u, v in edges}
msg.update({(v, u): np.zeros(unary.shape[1]) for u, v in edges})
for _ in range(iters):
new = {}
for (u, v), e_idx in zip(edges, range(len(edges))):
incoming = unary[u] + sum(msg[(w, u)] for w in neighbors(u) if w != v)
new[(u, v)] = np.logaddexp.reduce(
pairwise[e_idx] + incoming[:, None], axis=0)
new[(u, v)] -= new[(u, v)].max() # normalize
msg.update(new)
beliefs = np.array([
unary[v] + sum(msg[(u, v)] for u in neighbors(v))
for v in range(len(unary))])
return beliefs
```
### Linear-chain CRF (PyTorch — sequence labeling)
```python
import torch, torch.nn as nn
class LinearChainCRF(nn.Module):
def __init__(self, n_tags):
super().__init__()
self.trans = nn.Parameter(torch.randn(n_tags, n_tags))
def log_partition(self, emissions): # (T, K)
T, K = emissions.shape
alpha = emissions[0]
for t in range(1, T):
alpha = torch.logsumexp(
alpha[:, None] + self.trans + emissions[t][None, :], dim=0)
return torch.logsumexp(alpha, dim=0)
def score(self, emissions, tags):
s = emissions[0, tags[0]]
for t in range(1, len(tags)):
s = s + self.trans[tags[t-1], tags[t]] + emissions[t, tags[t]]
return s
def nll(self, emissions, tags):
return self.log_partition(emissions) - self.score(emissions, tags)
```
### Graph cut for binary MRF (submodular)
```python
import maxflow # PyMaxflow
def binary_mrf_graph_cut(unary_fg, unary_bg, pairwise_w):
H, W = unary_fg.shape
g = maxflow.Graph[float]()
nodes = g.add_grid_nodes((H, W))
g.add_grid_edges(nodes, pairwise_w) # smoothness
g.add_grid_tedges(nodes, unary_fg, unary_bg) # data term
g.maxflow()
return g.get_grid_segments(nodes) # bool mask
```
### Mean-field VI
```python
def mean_field(unary, pairwise, iters=10):
# q(x_v = k) ∝ exp(unary[v,k] + Σ_{u∈N(v)} Σ_l q(x_u=l) * pairwise[v,u,k,l])
q = torch.softmax(unary, dim=-1)
for _ in range(iters):
msg = torch.einsum('uvkl,ul->vk', pairwise, q)
q = torch.softmax(unary + msg, dim=-1)
return q
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Tree-structured | Sum-product (exact) |
| Loopy graph, fast | Loopy BP |
| Loopy graph, accurate | MCMC (Gibbs) — slower |
| Binary submodular | Graph cut (exact min-cut) |
| Sequence labeling (NER) | Linear-chain CRF |
| Image segmentation | Pairwise MRF + α-expansion / DenseCRF |
| Modern generative | Energy-Based Model (EBM) — score matching |
**기본값**: smallest model 의 first — chain → tree → loopy + BP → MCMC.
## 🔗 Graph
- 부모: [[Probabilistic Graphical Models]] · [[Probability Theory]]
- 응용: [[Image Segmentation]] · [[Energy-Based Model]]
- Adjacent: [[Bayesian Network]]
## 🤖 LLM 활용
**언제**: clique factorization 의 derive, BP/Gibbs pseudocode, partition-function intractability 의 explain.
**언제 X**: 매 specific paper algorithm — original 의 의 cross-check.
## ❌ 안티패턴
- **Bayes net 의 mental model 의 reuse**: 매 directionality 의 X — separation criterion 매 different.
- **Computing $Z$ for large graph**: 매 #P-hard — variational / MCMC.
- **Loopy BP on tightly-loopy graph**: 매 may diverge — damping 의 try, MCMC 의 fallback.
- **Linear-chain CRF 의 LSTM 으로 always replace**: 매 small data 의 still wins, 매 calibration 의 better.
- **Mean-field 의 multimodal posterior 의 use**: 매 mode-seeking — 매 underestimate variance.
## 🧪 검증 / 중복
- Verified (Hammersley & Clifford 1971; Koller & Friedman _PGM_ 2009; Murphy _PML_ 2022).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — MRF basics + BP/CRF/graph-cut 정리 |
10_Wiki/Topics/Domain_General/General Knowledge/Model-Free RL vs Model-Based RL.md
+179
View File
@@ -0,0 +1,179 @@
---
id: wiki-2026-0508-model-free-rl-vs-model-based-rl
title: Model-Free RL vs Model-Based RL
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [MFRL vs MBRL, Model-Based Reinforcement Learning, World Model]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [reinforcement-learning, machine-learning, planning, world-model]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: Python
framework: PyTorch/JAX
---
# Model-Free RL vs Model-Based RL
## 매 한 줄
> **"매 environment dynamics 의 learn 하나, 의 X 하나 — sample efficiency 의 vs simplicity 의 trade"**. Model-free (Q-learning, PPO) 매 reward signal 의 만으로 policy 의 update — simple 의 brittle. Model-based (Dreamer, MuZero) 매 world model 의 learn → 매 imagined rollout 의 train. 2026 의 Dreamer V3, EfficientZero, DayDreamer 의 robotics deployment — sample efficiency 의 1-2 orders.
## 매 핵심
### 매 dichotomy
- **Model-free**: $\pi(a|s)$ 또는 $Q(s,a)$ 의 직접 learn. 매 transition $p(s'|s,a)$ 의 access 의 X.
- **Model-based**: $\hat{p}(s'|s,a)$, $\hat{r}(s,a)$ 의 learn → 매 plan / imagined rollout / Dyna-style.
### 매 trade-off table
| Axis | Model-Free | Model-Based |
|---|---|---|
| Sample efficiency | Low | **High** (10-100×) |
| Compute per update | Low | **High** |
| Asymptotic perf | **Often higher** | Bounded by model error |
| Stability | **Stable** | Compounding model error |
| Transfer | Poor | **Better** (model 의 reuse) |
| Implementation | **Simple** | Complex |
### 매 modern flavors
- **Model-free**: PPO, SAC, DQN family, TD3.
- **Model-based**: Dreamer V3 (RSSM), MuZero (planning + value tree), TD-MPC2, PILCO (Gaussian process).
- **Hybrid**: MBPO (model-generated rollouts → SAC), Dyna-Q.
### 매 응용
1. Robotics (sample-efficient sim-to-real).
2. Atari/board game (MuZero).
3. Drug design (sample-efficient exploration).
4. Game NPC behavior (PPO 의 still default).
## 💻 패턴
### PPO — model-free policy gradient (gymnasium)
```python
import torch, torch.nn as nn, torch.nn.functional as F
from torch.distributions import Categorical
class ActorCritic(nn.Module):
def __init__(self, obs_dim, n_act):
super().__init__()
self.shared = nn.Sequential(nn.Linear(obs_dim, 64), nn.Tanh(),
nn.Linear(64, 64), nn.Tanh())
self.pi = nn.Linear(64, n_act)
self.v = nn.Linear(64, 1)
def forward(self, x):
h = self.shared(x)
return Categorical(logits=self.pi(h)), self.v(h).squeeze(-1)
def ppo_step(ac, opt, batch, clip=0.2, vf_c=0.5, ent_c=0.01):
dist, v = ac(batch.obs)
logp = dist.log_prob(batch.act)
ratio = torch.exp(logp - batch.logp_old)
surr1 = ratio * batch.adv
surr2 = torch.clamp(ratio, 1-clip, 1+clip) * batch.adv
pi_loss = -torch.min(surr1, surr2).mean()
v_loss = F.mse_loss(v, batch.ret)
ent = dist.entropy().mean()
loss = pi_loss + vf_c * v_loss - ent_c * ent
opt.zero_grad(); loss.backward(); opt.step()
return loss.item()
```
### Dreamer-style world model (RSSM skeleton)
```python
class RSSM(nn.Module):
def __init__(self, obs_dim, act_dim, h=200, z=32):
super().__init__()
self.gru = nn.GRUCell(z + act_dim, h)
self.prior = nn.Linear(h, 2 * z) # μ, σ
self.post = nn.Linear(h + obs_dim, 2 * z)
self.dec_obs = nn.Linear(h + z, obs_dim)
self.dec_rew = nn.Linear(h + z, 1)
def step(self, h, z, a, obs=None):
h = self.gru(torch.cat([z, a], -1), h)
pri_mu, pri_log = self.prior(h).chunk(2, -1)
if obs is not None:
po_mu, po_log = self.post(torch.cat([h, obs], -1)).chunk(2, -1)
z = po_mu + torch.exp(po_log) * torch.randn_like(po_mu)
else:
z = pri_mu + torch.exp(pri_log) * torch.randn_like(pri_mu)
return h, z, (pri_mu, pri_log)
def imagine(self, h, z, policy, T=15):
states = []
for _ in range(T):
a = policy(torch.cat([h, z], -1))
h, z, _ = self.step(h, z, a)
states.append((h, z))
return states
```
### Dyna-Q (hybrid — tabular)
```python
def dyna_q(env, n_planning=10, episodes=500, alpha=0.1, gamma=0.99, eps=0.1):
Q = defaultdict(lambda: np.zeros(env.action_space.n))
model = {} # (s,a) → (r, s')
for _ in range(episodes):
s, _ = env.reset()
done = False
while not done:
a = np.random.randint(env.action_space.n) if np.random.random() < eps \
else int(np.argmax(Q[s]))
s2, r, done, *_ = env.step(a)
Q[s][a] += alpha * (r + gamma * Q[s2].max() - Q[s][a])
model[(s, a)] = (r, s2)
for _ in range(n_planning): # 매 imagined step
(sp, ap), (rp, sp2) = random.choice(list(model.items())), None
rp, sp2 = model[(sp, ap)]
Q[sp][ap] += alpha * (rp + gamma * Q[sp2].max() - Q[sp][ap])
s = s2
```
### MuZero (planning sketch — value/policy net + MCTS)
```python
# 매 environment 의 black-box; learned (representation, dynamics, prediction) heads
# search 매 imagined trajectory 의 over MCTS — replay 매 (search policy, search value, n-step return)
# 의 train. (full impl 매 muzero_general repo)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Lots of cheap simulation | **Model-free** (PPO/SAC) — simpler |
| Real-robot, expensive samples | **Model-based** (Dreamer V3, TD-MPC2) |
| Discrete board game | **MuZero** — planning 의 wins |
| Continuous control benchmark | SAC or DreamerV3 |
| Fast prototype | PPO — most stable, easiest to tune |
| Long-horizon planning | Model-based + planning |
**기본값**: prototype 매 PPO. Sample 매 expensive — Dreamer V3 / TD-MPC2.
## 🔗 Graph
- 부모: [[Reinforcement Learning]]
- 변형: [[PPO]]
- Adjacent: [[World Model]] · [[Planning]]
## 🤖 LLM 활용
**언제**: trade-off explanation, algorithm choice, pseudocode skeleton.
**언제 X**: 매 hyperparameter — paper-specific 의 cross-check (Dreamer V3 매 sensitivity 의 paper 의 careful).
## ❌ 안티패턴
- **MBRL 의 default 의 reach**: 매 cheap-sim 환경 의 PPO 의 win 매 simpler.
- **Imagined rollout 의 too-long horizon**: 매 model error compounds — 5-15 step 의 typical.
- **MFRL 의 sparse reward 의 hope**: 매 exploration 의 add (RND, ICM) — 또는 의 model-based 의 switch.
- **MuZero 의 small problem 의 use**: 매 overkill — tabular Q 의 enough.
- **Single-seed report**: 매 RL variance huge — 5+ seeds 의 IQM (Agarwal et al. 2021).
## 🧪 검증 / 중복
- Verified (Sutton & Barto 2nd ed. 2018; Hafner _DreamerV3_ 2023; Schrittwieser _MuZero_ Nature 2020).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — MFRL/MBRL trade-off + DreamerV3/MuZero 정리 |
10_Wiki/Topics/Domain_General/General Knowledge/Mycological Horror.md
+136
View File
@@ -0,0 +1,136 @@
---
id: wiki-2026-0508-mycological-horror
title: Mycological Horror
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Fungal Horror, Mushroom Horror, Cordyceps Horror]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [horror, genre, biology, fiction, body-horror]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: N/A
framework: literary-genre
---
# Mycological Horror
## 매 한 줄
> **"매 fungus 의 host 의 takeover — body autonomy 의 loss"**. 매 ergot poisoning 의 medieval witch trial 부터, William Hope Hodgson 의 "The Voice in the Night" (1907), Jeff VanderMeer 의 _Annihilation_ (2014), HBO _The Last of Us_ (2023/2025) 까지 — 매 fungus 의 alien intelligence + human host 의 dissolve 의 anxiety. 2026 climate-fiction 안에서 매 still rising subgenre.
## 매 핵심
### 매 horror axes
- **Body horror**: 매 visible mycelium 의 bursting — Cronenbergian rupture.
- **Loss of selfhood**: 매 host 의 mind 의 still 있나? — zombie/possession 의 fungal flavor.
- **Ecological dread**: 매 fungus 의 deep time, 매 forest network — humans 의 just substrate.
- **Inscrutable intelligence**: 매 distributed cognition — neither animal nor "thinking" of typical sense.
### 매 biological substrate
- **_Ophiocordyceps unilateralis_**: 매 ant 의 brain 의 hijack — 매 height 의 climb 후 spore release. 매 Last of Us 의 inspiration.
- **Ergot (_Claviceps purpurea_)**: 매 LSD-precursor — Salem witch trial 의 hypothesis.
- **_Massospora_** on cicadas: 매 hypersexual zombie cicada.
- **Mycorrhizal networks**: 매 forest "wood-wide web" (Suzanne Simard) — 매 nonhuman intelligence trope 의 source.
### 매 응용
1. Game design (The Last of Us, Returnal biome).
2. Cosmic-horror / weird-fiction adjacency.
3. Climate-fiction (mass extinction + fungal succession).
4. Folk-horror revival (witch & ergot tradition).
## 💻 패턴
### Trope catalog (writer's reference)
```yaml
core_tropes:
- infection_to_transformation:
stages: [exposure, asymptomatic, behavioral_change, sporulation, death]
pacing: slow_creep # 매 not jump-scare
- hivemind_vs_individual:
tension: "is the host still in there?"
- spore_cloud:
sensory: "sweet rot, gold dust, cathedral silence"
- fruiting_body:
visual: "antlers, coral, cathedral arches from skin"
- mycorrhizal_network:
scale: "forest-wide consciousness"
```
### Game-design beat (procgen biome)
```python
# 매 fungal biome 의 generative beat — escalation curve
def fungal_zone(progress: float) -> dict:
return {
"spore_density": progress ** 1.4, # 매 quadratic creep
"mass_size_m": 0.2 + 8 * progress,
"infected_npcs": int(20 * progress),
"biome_audio": "low_drone" if progress < 0.5 else "wet_chittering",
"visibility_m": max(2, 30 - 28 * progress),
}
```
### Slow-reveal scene template (prose)
```
Beat 1 (page 1) : odd smell, "sweet rot" # sensory only
Beat 2 (page 3) : gold dust on the windowsill # mundane anomaly
Beat 3 (page 7) : neighbor's strange stillness # social uncanny
Beat 4 (page 12) : mycelium under the wallpaper # body discovery
Beat 5 (climax) : the host speaks in chorus # selfhood collapse
```
### Sound-design palette (game/film)
```
- low sub drone (40-60 Hz) # 매 dread bed
- wet chittering / squelch # 매 body-rupture cues
- choral vowel pads # 매 hivemind voice
- silence in canopy # 매 ecology-wrong cue
- distant tonal "pop" # 매 spore release
```
### Reference shelf
```markdown
- William Hope Hodgson, "The Voice in the Night" (1907)
- Jeff VanderMeer, _Annihilation_ (2014) and the Southern Reach
- M. R. Carey, _The Girl With All the Gifts_ (2014)
- _The Last of Us_ (2013/2020 game; HBO 2023/2025)
- Mira Grant, _Parasite_ (adjacent — protozoan, not fungal)
- Kingsnorth, _The Wake_ (folk-horror adjacent)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Body horror beat | Slow reveal (5 beats) — visible mycelium late |
| Cosmic horror tone | Mycorrhizal network 의 emphasize — scale 의 dread |
| Action game | Cordyceps-style infected — clear stage progression |
| Folk horror | Ergot + village — historical anchor |
| Climate fiction | Succession after collapse — fungus 의 inheritor |
**기본값**: slow-creep + sensory anomaly 의 lead, body horror 의 climax 의 reserve.
## 🔗 Graph
## 🤖 LLM 활용
**언제**: trope catalog, beat structure, sound palette, reference suggestion.
**언제 X**: 매 actual mycology — biology fact 의 source 의 cross-check (Sheldrake _Entangled Life_).
## ❌ 안티패턴
- **Zombie reskin**: 매 just "fungal zombie" — fungus 의 unique anxiety (network, slow time, ecology) 의 lose.
- **Jump-scare reliance**: 매 mycological horror 의 strength 의 slow creep — jump scare 매 incompatible.
- **Cure-of-the-week ending**: 매 fungus 의 horror 매 inseparable — antibiotic-style cure 의 deflate.
- **Misidentifying biology**: 매 cordyceps 의 "controls brain via puppeteer" — actually 의 muscle hijack, brain 의 dies. 매 detail 매 matter 의 weird-fiction 의 reader.
## 🧪 검증 / 중복
- Verified (VanderMeer _Annihilation_ 2014; Hughes et al. on _Ophiocordyceps_ 2011 _BMC Ecology_; Sheldrake _Entangled Life_ 2020).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — tropes + biology + design beat 정리 |
10_Wiki/Topics/Domain_General/General Knowledge/README.md
+160
View File
@@ -0,0 +1,160 @@
---
id: wiki-2026-0508-readme
title: README — General Knowledge
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [P-REINFORCE-AUTO-698D8B]
duplicate_of: none
source_trust_level: A
confidence_score: 0.95
verification_status: applied
tags: [readme, index, meta]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
---
# README — General Knowledge
## 매 한 줄
> **"매 cross-domain knowledge 의 hub"**. 매 General Knowledge folder 는 narrowly-scoped 도메인에 fit 하지 않은 wiki note 의 catch-all index — game design, web platform, ML theory, neuroscience 가 cross-pollinate 한다.
## 매 핵심
### 매 폴더 목적
- 매 cross-domain note 의 home — 매 specific topic folder (AI_and_ML, Programming) 에 fit 하지 않은 entry.
- 매 case study + concept primer 의 mix.
- 매 canonical 문서 + redirect 문서 의 coexist.
### 매 분류 체계
- 매 status: `verified` (canonical), `duplicate` (redirect), `merged` (filename-level redirect), `needs_review` (pending cleanup).
- 매 canonical_id: `self` (own canonical) or external canonical slug.
- 매 frontmatter 의 일관된 schema — id, title, category, status, canonical_id, aliases, source_trust_level.
### 매 응용
1. Game design knowledge base — Albion Online, Clash Royale, Diablo 2 의 case study.
2. Web platform primer — OffscreenCanvas, SharedArrayBuffer 의 깊이 있는 reference.
3. Cognitive science index — Dopamine Signaling, Mycological Horror 의 cross-cut topic.
## 💻 패턴
### 패턴 1: Frontmatter linting
```python
import yaml
import frontmatter
from pathlib import Path
REQUIRED = {"id", "title", "category", "status", "canonical_id"}
def lint_folder(folder: Path):
issues = []
for md in folder.glob("*.md"):
post = frontmatter.load(md)
missing = REQUIRED - set(post.metadata.keys())
if missing:
issues.append((md.name, f"missing: {missing}"))
return issues
for name, issue in lint_folder(Path("./General Knowledge")):
print(f"{name}: {issue}")
```
### 패턴 2: Duplicate detection (title similarity)
```python
from rapidfuzz import fuzz
from pathlib import Path
import frontmatter
def find_dupes(folder: Path, threshold=85):
titles = []
for md in folder.glob("*.md"):
post = frontmatter.load(md)
titles.append((md.name, post.metadata.get("title", "")))
pairs = []
for i, (n1, t1) in enumerate(titles):
for n2, t2 in titles[i+1:]:
score = fuzz.ratio(t1, t2)
if score >= threshold:
pairs.append((n1, n2, score))
return pairs
```
### 패턴 3: Wikilink graph build
```python
import re
import networkx as nx
from pathlib import Path
LINK_RE = re.compile(r"\[\[([^\]]+)\]\]")
def build_graph(folder: Path) -> nx.DiGraph:
g = nx.DiGraph()
for md in folder.glob("*.md"):
text = md.read_text()
for target in LINK_RE.findall(text):
g.add_edge(md.stem, target.split("|")[0])
return g
g = build_graph(Path("./General Knowledge"))
print(f"nodes={g.number_of_nodes()} edges={g.number_of_edges()}")
print("orphans:", [n for n in g.nodes if g.in_degree(n) == 0])
```
### 패턴 4: Redirect resolution
```python
def resolve(slug: str, index: dict[str, dict]) -> str:
seen = set()
cur = slug
while cur in index and index[cur].get("status") in ("duplicate", "merged"):
if cur in seen:
raise ValueError(f"redirect cycle at {cur}")
seen.add(cur)
cur = index[cur].get("canonical_id") or index[cur].get("redirect_to")
return cur
```
### 패턴 5: Reinforcement scheduler
```python
from datetime import date, timedelta
def needs_reinforcement(meta: dict, today: date = date.today()) -> bool:
last = date.fromisoformat(meta["last_reinforced"])
score = float(meta.get("confidence_score", 0.9))
interval = timedelta(days=30 if score >= 0.9 else 14)
return today - last > interval
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 새 note 의 fit folder 가 명확 | specific folder 에 add (not General Knowledge) |
| cross-domain note | General Knowledge |
| Korean title duplicate | REDIRECT to English canonical |
| stub / placeholder | redirect to README |
**기본값**: domain-specific folder 우선, fallback 만 General Knowledge.
## 🔗 Graph
- 부모: [[Wiki Index]] · [[10_Wiki/Topics]]
- 변형: [[AI_and_ML/README]] · [[Programming & Language/README]]
## 🤖 LLM 활용
**언제**: cross-domain question 의 routing, knowledge graph 구축, reinforcement scheduling.
**언제 X**: 매 specific domain 의 deep query — domain folder 의 직접 lookup 우선.
## ❌ 안티패턴
- **Catch-all dumping**: 매 note 가 specific folder 의 candidate 인데 General Knowledge 에 dump — graph 의 fragmentation.
- **Redirect chain**: 매 redirect → redirect → canonical 의 multi-hop. 매 single-hop 으로 flatten.
- **Stale frontmatter**: 매 last_reinforced 의 90+일 미갱신 — reinforcement loop 의 break.
## 🧪 검증 / 중복
- Verified (folder ls + frontmatter lint).
- 신뢰도 A (meta-doc, self-describing).
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — README 의 substantive content 화 |
10_Wiki/Topics/Domain_General/General Knowledge/Variance-Rules.md
+156
View File
@@ -0,0 +1,156 @@
---
id: wiki-2026-0508-variance-rules
title: Variance Rules
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Variance Algebra, Var Properties, Bienaymé Identity]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [statistics, probability, math, identity]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: Python
framework: NumPy
---
# Variance Rules
## 매 한 줄
> **"매 random variable 의 spread 의 algebra — Var(aX + b) = a²Var(X), 매 independence 매 sum 의 add"**. 1853 Bienaymé 의 sum-of-independent identity 부터 매 modern propagation-of-uncertainty, finance VaR, ML loss decomposition 까지 — 매 variance algebra 의 매 day-1 statistics 의 still 매 most-used identity.
## 매 핵심
### 매 core identities
- **Definition**: $\mathrm{Var}(X) = \mathbb{E}[(X - \mathbb{E}[X])^2] = \mathbb{E}[X^2] - \mathbb{E}[X]^2$.
- **Affine**: $\mathrm{Var}(aX + b) = a^2 \mathrm{Var}(X)$ — 매 constant $b$ 의 drop.
- **Sum**: $\mathrm{Var}(X + Y) = \mathrm{Var}(X) + \mathrm{Var}(Y) + 2\,\mathrm{Cov}(X, Y)$.
- **Independence (Bienaymé)**: $X \perp Y \Rightarrow \mathrm{Var}(X+Y) = \mathrm{Var}(X) + \mathrm{Var}(Y)$.
- **Linear comb**: $\mathrm{Var}\!\left(\sum a_i X_i\right) = \sum a_i^2 \mathrm{Var}(X_i) + 2 \sum_{i<j} a_i a_j \mathrm{Cov}(X_i, X_j)$.
- **Law of total variance**: $\mathrm{Var}(Y) = \mathbb{E}[\mathrm{Var}(Y|X)] + \mathrm{Var}(\mathbb{E}[Y|X])$.
- **Sample variance bias correction**: $s^2 = \frac{1}{n-1}\sum (x_i - \bar{x})^2$ — 매 Bessel.
### 매 propagation (delta method)
- **Univariate**: $\mathrm{Var}(g(X)) \approx (g'(\mu))^2 \mathrm{Var}(X)$.
- **Multivariate**: $\mathrm{Var}(g(\mathbf{X})) \approx \nabla g(\mu)^\top \Sigma \nabla g(\mu)$.
### 매 응용
1. Portfolio variance (Markowitz).
2. Error propagation in physics measurement.
3. ML bias-variance decomposition.
4. A/B test sample-size (Welch).
5. Kalman filter — covariance propagation.
## 💻 패턴
### Numerical sample variance — Welford (numerically stable)
```python
def welford_variance(stream):
n = 0; mean = 0.0; M2 = 0.0
for x in stream:
n += 1
delta = x - mean
mean += delta / n
M2 += delta * (x - mean) # 매 use updated mean
return mean, M2 / (n - 1) if n > 1 else float('nan')
```
### Linear combination variance
```python
import numpy as np
def linear_combo_var(weights, cov):
# Var(w^T X) = w^T Σ w
w = np.asarray(weights); cov = np.asarray(cov)
return float(w @ cov @ w)
```
### Portfolio variance (Markowitz)
```python
def portfolio_var(weights, returns_matrix):
cov = np.cov(returns_matrix, rowvar=False, ddof=1)
return weights @ cov @ weights
```
### Delta-method propagation
```python
import numpy as np
def delta_method(g, grad_g, mu, sigma):
# mu: vector, sigma: covariance
g_grad = np.asarray(grad_g(mu))
return float(g_grad @ sigma @ g_grad)
```
### Law of total variance — verify by simulation
```python
import numpy as np
rng = np.random.default_rng(0)
N = 1_000_000
X = rng.integers(0, 3, size=N) # 매 latent class
mu_y = np.array([0.0, 1.0, 5.0])[X]
Y = rng.normal(mu_y, scale=1.0)
total = Y.var()
inner = np.array([Y[X==k].var() for k in range(3)]).mean()
outer = np.array([Y[X==k].mean() for k in range(3)]).var()
print(total, inner + outer) # 매 ≈ equal
```
### Bias-variance decomposition (ML)
```python
def bias_variance(predictions, y_true):
# predictions: (n_models, n_samples)
mean_pred = predictions.mean(axis=0)
bias_sq = ((mean_pred - y_true) ** 2).mean()
var = predictions.var(axis=0).mean()
noise_lb = 0.0 # 매 estimable 의 의 separately
return bias_sq, var, noise_lb
```
### Welch's t-test variance handling
```python
from scipy import stats
t, p = stats.ttest_ind(a, b, equal_var=False) # Welch
# 매 unequal variance — Satterthwaite degrees of freedom
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Streaming variance | Welford (numerically stable) |
| Independent sum | Bienaymé — sum the variances |
| Correlated sum | Full covariance — $w^\top \Sigma w$ |
| Nonlinear function $g(X)$ | Delta method (1st-order) — or Monte Carlo |
| Hierarchical / mixture | Law of total variance 의 decompose |
| ML overfitting diagnose | Bias-variance decomposition |
| Sample variance | Bessel correction ($n-1$) |
**기본값**: independence 의 confirm 후 Bienaymé. Doubt — Monte Carlo 의 verify.
## 🔗 Graph
- 부모: [[Probability Theory]]
- 응용: [[Bias-Variance Tradeoff]]
## 🤖 LLM 활용
**언제**: identity recall, derivation hint, code skeleton (Welford, delta).
**언제 X**: 매 specific paper 의 closed-form — derivation 의 cross-check.
## ❌ 안티패턴
- **Bienaymé 의 correlated variable 의 apply**: 매 covariance 의 forget — biased toward zero variance.
- **Two-pass naive variance** ($\sum x_i^2 - (\sum x_i)^2/n$): 매 catastrophic cancellation — Welford 의 use.
- **Sample variance with $n$**: 매 biased — Bessel ($n-1$).
- **Affine 매 $b$ 의 add to variance**: 매 $b$ 의 drop, only $a^2$ matters.
- **Delta method 의 high curvature 의 use**: 매 1st-order — large $\sigma$ 의 의 break, 의 Monte Carlo.
## 🧪 검증 / 중복
- Verified (Bienaymé 1853; Casella & Berger _Statistical Inference_ 2nd ed.; Welford 1962 _Technometrics_).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — variance algebra + Welford + delta method 정리 |
10_Wiki/Topics/Domain_General/General Knowledge/디아블로 2(Diablo II) 조던링 사태.md
+32
View File
@@ -0,0 +1,32 @@
---
id: wiki-2026-0508-디아블로-2-diablo-ii-조던링-사태
title: 디아블로 2(Diablo II) 조던링 사태
category: 10_Wiki/Topics
status: duplicate
canonical_id: diablo-2-economy
duplicate_of: "[[Game Economy Case Studies]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, game-economy, diablo, dupe-bug]
last_reinforced: 2026-05-10
github_commit: pending
---
# 디아블로 2(Diablo II) 조던링 사태
> **이 문서는 [[Game Economy Case Studies]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (specialization aspects)
- 매 SOJ(Stone of Jordan) 의 de facto currency 화 — gold inflation 의 결과.
- 매 dupe bug + bot economy 의 hyperinflation 사례.
## 🔗 Graph
- Adjacent: [[Resource Management]] · [[Free-to-Play]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/General Knowledge/부분 유료화(Free-to-Play) 게임.md
+154
View File
@@ -0,0 +1,154 @@
---
id: wiki-2026-0508-부분-유료화-free-to-play-게임
title: 부분 유료화(Free-to-Play) 게임
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [F2P, Free-to-Play, 부분유료, 프리투플레이]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [f2p, monetization, mobile, gacha, battle-pass]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: typescript
framework: nodejs
---
# 부분 유료화(Free-to-Play) 게임
## 매 한 줄
> **"매 entry 의 free + 매 in-game purchase 의 monetize"**. 매 2000s Asian PC MMO 에서 출발 — 매 2010s mobile 의 dominant model. 매 2026 의 industry: 매 mobile gross revenue 의 약 ~80% + 매 console / PC 의 hybrid F2P (Fortnite, Apex, Marvel Rivals) 의 mainstream.
## 매 핵심
### 매 monetization archetype
- **Cosmetic-only**: 매 Fortnite / Valorant — 매 pay-for-look.
- **Convenience**: 매 Genshin resin refresh — 매 pay-for-time.
- **Power (gacha)**: 매 Honkai / Diablo Immortal — 매 pay-for-stat.
- **Battle pass**: 매 across all archetype — 매 standardize 됨 (2018+).
### 매 player segment
- **Whale** (top 1%, ~50% revenue).
- **Dolphin** (next 10%, ~30%).
- **Minnow** (next ~30%, ~20%).
- **Free** (60%+, 매 0 revenue + 매 retention/ecosystem 의 contribute).
### 매 design lever
- **Pacing wall**: 매 free progression 의 deliberate slow.
- **Premium currency**: 매 dual-currency 의 obfuscate price.
- **Limited offer**: 매 24h flash sale + 매 anchor pricing.
- **Soft / hard pity**: 매 gacha 의 expected-value floor.
## 💻 패턴
### Dual currency (premium / soft)
```typescript
class Wallet {
gems: number = 0; // premium (paid)
coins: number = 0; // soft (earned)
spend(cost: { gems?: number; coins?: number }) {
if ((cost.gems ?? 0) > this.gems) return false;
if ((cost.coins ?? 0) > this.coins) return false;
this.gems -= cost.gems ?? 0;
this.coins -= cost.coins ?? 0;
return true;
}
}
```
### Gacha with soft + hard pity
```typescript
function pull(state: GachaState) {
state.pullsSinceSSR++;
const baseRate = 0.006;
const softFloor = state.pullsSinceSSR >= 75
? baseRate + (state.pullsSinceSSR - 74) * 0.06
: baseRate;
const isSSR = state.pullsSinceSSR >= 90 || Math.random() < softFloor;
if (isSSR) state.pullsSinceSSR = 0;
return { isSSR, pity: state.pullsSinceSSR };
}
```
### Battle pass tier
```typescript
function unlockedRewards(xp: number, hasPremium: boolean, season: Season) {
const tier = tierFromXP(xp, season);
return season.rewards
.slice(0, tier)
.filter(r => hasPremium || r.track === 'free');
}
```
### Time-gated resin
```typescript
function regenResin(state: ResinState, now: number) {
const elapsed = now - state.lastUpdate;
state.value = Math.min(160, state.value + Math.floor(elapsed / 480_000));
state.lastUpdate = now;
}
```
### Daily flash offer (anchor pricing)
```typescript
function todayOffer(userId: string) {
const seg = classify(userId);
return {
sku: 'gem_pack_500',
originalPrice: 9.99,
discountedPrice: seg === 'minnow' ? 1.99 : 4.99,
expiresAt: endOfDay(),
};
}
```
### Spending guardrail (regulatory)
```typescript
async function chargeIAP(userId, amount) {
const monthly = await wallet.monthlySpend(userId);
if (monthly + amount > REGION_CAP[user.region]) {
return { ok: false, reason: 'monthly_cap' };
}
return iap.charge(userId, amount);
}
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 PvP shooter | 매 cosmetic-only (avoid pay-to-win) |
| 매 gacha RPG | 매 character banner + 매 soft pity 75 / hard 90 |
| 매 strategy / 4X | 매 convenience (speed-up) + 매 cosmetic |
| 매 hyper-casual | 매 ad-based + 매 remove-ads IAP |
**기본값**: 매 BP + 매 cosmetic + 매 1 convenience SKU — 매 PvP 의 trust 의 maintain.
## 🔗 Graph
- 부모: [[Game Monetization]]
- 변형: [[Gacha]]
- 응용: [[원신(Genshin Impact)]] · [[클래시 로얄(Clash Royale)]] · [[알비온 온라인(Albion Online)]]
- Adjacent: [[라이브옵스(LiveOps)]] · [[데이터 기반 밸런싱]]
## 🤖 LLM 활용
**언제**: 매 SKU copy 의 generation / localization, 매 monetization spec 의 review, 매 player segment 의 narrative profile.
**언제 X**: 매 actual pricing decision — 매 elasticity 의 empirical A/B test 의 필수.
## ❌ 안티패턴
- **Pay-to-win in PvP**: 매 trust collapse + 매 esports 의 viability 의 destroy.
- **Hidden gacha rate**: 매 regulatory risk (China, S. Korea, Belgium 의 disclosure mandate).
- **Whale farming**: 매 top 0.1% 의 only target → 매 community erosion.
- **Aggressive FOMO**: 매 24/7 limited offer → 매 burnout / churn.
## 🧪 검증 / 중복
- Verified (Sensor Tower 2026 mobile report, GDC 2024-2025 monetization talks, 한국 게임산업진흥원 자율규제).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — archetype + segment + gacha/BP pattern |
10_Wiki/Topics/Domain_General/General Knowledge/비디오 게임 산업의 플랫폼 융합(Platform Convergence).md
+142
View File
@@ -0,0 +1,142 @@
---
id: wiki-2026-0508-비디오-게임-산업의-플랫폼-융합-platform-conve
title: 비디오 게임 산업의 플랫폼 융합(Platform Convergence)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Platform Convergence, Cross-Platform, 멀티플랫폼]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [platform, cross-play, cloud-gaming, industry, distribution]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: cpp
framework: unreal
---
# 비디오 게임 산업의 플랫폼 융합(Platform Convergence)
## 매 한 줄
> **"매 console / PC / mobile / cloud 의 boundary 의 erode + 매 single account / single progression 의 unification"**. 매 2010s 후반 의 Fortnite cross-play (2018) 가 catalyst — 매 2026 의 modern: 매 Microsoft Activision-Blizzard 인수 (2023) + 매 Game Pass cloud + 매 mobile-console hybrid (Genshin, COD Mobile) 의 mainstream.
## 매 핵심
### 매 4 convergence axis
- **Cross-play**: 매 input parity / matchmaking pool 의 unify.
- **Cross-progression**: 매 save / inventory / BP 의 cloud-sync.
- **Cross-purchase**: 매 single SKU 의 multi-platform entitlement.
- **Cross-platform commerce**: 매 unified store / wallet (Epic Games Store, Xbox).
### 매 driver
- **Hardware parity**: 매 mobile chip 의 console-class (A18 Pro, Snapdragon 8 Gen 4).
- **Cloud streaming**: 매 GeForce Now / xCloud / PS Cloud — 매 device-agnostic.
- **Engine portability**: 매 Unreal 5.4 / Unity 6 의 1-codebase multi-target.
- **Regulatory pressure**: 매 EU DMA / 매 epic-vs-apple 의 store competition.
### 매 friction point
- **Input asymmetry**: 매 KB+M vs gamepad vs touch — 매 fairness.
- **Platform fee**: 매 30% 의 historical cut + 매 alternative store 의 fragmentation.
- **Monetization rule divergence**: 매 Apple loot-box rule vs 매 Google vs 매 console.
## 💻 패턴
### Cross-play matchmaking with input bucket
```cpp
enum class InputType { Touch, Gamepad, KBM };
struct MatchPool {
InputType type;
std::vector<Player> queue;
};
void enqueue(Player p) {
pools[p.input].queue.push_back(p);
if (p.allowsCrossInput) pools[p.input | CROSS].queue.push_back(p);
}
```
### Cross-progression sync
```cpp
void OnLogin(UserId u, Platform p) {
auto cloud = CloudSave::Fetch(u);
auto local = LocalSave::Load(p);
auto merged = Merge(cloud, local); // last-write-wins per shard
CloudSave::Push(u, merged);
}
```
### Entitlement check (cross-purchase)
```cpp
bool HasItem(UserId u, ItemId i) {
for (auto& p : LinkedPlatforms(u)) {
if (Entitlements::Has(p, u, i)) return true;
}
return false;
}
```
### Cloud render fallback
```cpp
void RenderFrame() {
if (device.gpuTier < kMinTier) {
cloud.StreamFrame(); // GeForce Now style
} else {
local.RenderFrame();
}
}
```
### Platform-specific monetization gate
```cpp
SkuList AvailableSkus(Platform p) {
auto skus = baseSkus;
if (p == Platform::iOS_KR) skus.removeIf(s => s.kind == "lootbox");
if (p == Platform::Web) skus.add(directWebPaymentSkus);
return skus;
}
```
### Build matrix CI
```yaml
matrix:
platform: [windows, ps5, xbox, switch2, ios, android, linux-cloud]
config: [shipping, dev]
steps:
- run: ue5 BuildCookRun -platform=${{ platform }}
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 PvP competitive | 매 input-bucket 의 enforce + 매 opt-in cross |
| 매 PvE / co-op | 매 full cross-play default |
| 매 mobile-first | 매 cloud progression + 매 touch-optimized UI |
| 매 console exclusive | 매 cross-progression 의 only (no cross-play) |
**기본값**: 매 cross-play (input-bucketed) + 매 cross-progression + 매 cross-purchase (where store policy 의 allow).
## 🔗 Graph
- 변형: [[Cloud Gaming]]
- 응용: [[원신(Genshin Impact)]] · [[Fortnite]]
## 🤖 LLM 활용
**언제**: 매 platform-specific compliance text 의 generation, 매 SKU matrix 의 review, 매 industry trend 의 summarize.
**언제 X**: 매 legal compliance 의 final decision — 매 jurisdiction-specific lawyer 의 review 의 mandatory.
## ❌ 안티패턴
- **Forced cross-input PvP**: 매 KB+M vs touch 의 mix → 매 unfair.
- **Last-write-wins save 의 unconditional**: 매 cloud merge bug → 매 progression loss.
- **Single-platform monetization assumption**: 매 Apple/Google rule 의 ignore → 매 store rejection.
## 🧪 검증 / 중복
- Verified (Newzoo 2026 platform report, Microsoft 10-K 2024, Apple App Store guidelines 2026).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — convergence axis + driver + 6 patterns |
10_Wiki/Topics/Domain_General/General Knowledge/사용자 제작 콘텐츠(UGC).md
+34
View File
@@ -0,0 +1,34 @@
---
id: wiki-20260508--ugc--redir
title: 사용자 제작 콘텐츠(UGC)
category: 10_Wiki/Topics
status: duplicate
canonical_id: wiki-2026-0508-user-generated-content
duplicate_of: "[[User Generated Content]]"
aliases: [UGC, User-Generated Content]
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, ugc, game-design, platform]
last_reinforced: 2026-05-10
github_commit: pending
---
# 사용자 제작 콘텐츠(UGC)
> **이 문서는 [[User Generated Content]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- 매 player 의 create / share / monetize content 의 game platform.
- 매 Roblox / Fortnite UEFN / Minecraft / Dreams 의 representative.
- 매 2026 의 trend: 매 AI-assisted creation tool 의 integration (Roblox Cube, UEFN AI scaffolding).
## 🔗 Graph
- 부모: [[User Generated Content]] (canonical)
- 인접: [[Roblox]] · [[Platform Convergence]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/General Knowledge/알비온 온라인(Albion Online) 암시장 시스템.md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-알비온-온라인-albion-online-암시장-시스템
title: 알비온 온라인(Albion Online) 암시장 시스템
category: 10_Wiki/Topics
status: duplicate
canonical_id: albion-online
duplicate_of: "[[Albion Online (Full LootPlayer-Driven Production)|Albion Online]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, mmo, economy, albion]
last_reinforced: 2026-05-10
github_commit: pending
---
# 알비온 온라인(Albion Online) 암시장 시스템
> **이 문서는 [[Albion Online (Full LootPlayer-Driven Production)|Albion Online]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (specialization aspects)
- 매 Black Market NPC — player crafted gear 의 sink mechanism.
- 매 mob loot drop 의 supply 가 player-crafted item 으로 routed.
## 🔗 Graph
- 부모: [[Albion Online (Full LootPlayer-Driven Production)|Albion Online]] (canonical)
- Adjacent: [[Resource Management]]
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/General Knowledge/알비온 온라인(Albion Online).md
+33
View File
@@ -0,0 +1,33 @@
---
id: wiki-2026-0508-알비온-온라인-albion-online
title: 알비온 온라인(Albion Online)
category: 10_Wiki/Topics
status: duplicate
canonical_id: albion-online
duplicate_of: "[[Albion Online (Full LootPlayer-Driven Production)|Albion Online]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, mmorpg, sandbox, game]
last_reinforced: 2026-05-10
github_commit: pending
---
# 알비온 온라인(Albion Online)
> **이 문서는 [[Albion Online (Full LootPlayer-Driven Production)|Albion Online]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약 (specialization aspects)
- Sandbox Interactive (베를린) 매 cross-platform sandbox MMORPG (2017 출시).
- 매 player-driven economy + full-loot PvP + classless "you are what you wear" 시스템.
- 매 single-shard global server (Americas/EU/Asia regional gateway 통합 2023).
## 🔗 Graph
- 부모: [[Albion Online (Full LootPlayer-Driven Production)|Albion Online]] (canonical)
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
10_Wiki/Topics/Domain_General/General Knowledge/클래시 로얄(Clash Royale)의 비용-엘릭서 밸런싱.md
+145
View File
@@ -0,0 +1,145 @@
---
id: wiki-2026-0508-클래시-로얄-clash-royale-의-비용-엘릭서-밸런싱
title: 클래시 로얄(Clash Royale)의 비용-엘릭서 밸런싱
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Clash Royale Elixir Balance, 엘릭서 밸런스]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [clash-royale, balancing, elixir, supercell, mobile-pvp, case-study]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: simulation
---
# 클래시 로얄(Clash Royale)의 비용-엘릭서 밸런싱
## 매 한 줄
> **"매 elixir cost 1~9 의 single resource 의 design 으로 매 100+ card 의 균형"**. 매 Supercell 의 2016 launch 이래 매 monthly balance update 의 backbone — 매 elixir-per-second (EPS) regen + 매 card cost + 매 stat budget 의 triangle. 매 2026 의 evolution mechanic 의 도입 으로 매 budget 재계산.
## 매 핵심
### 매 elixir economy 의 base
- **Regen rate**: 매 1 elixir / 2.8s (normal) → 매 / 1.4s (double) → 매 / 0.93s (triple, overtime).
- **Cap**: 매 10 elixir 의 hard ceiling — 매 hoarding 의 prevent.
- **Cost band**: 매 1 (Skeletons) ~ 매 9 (Three Musketeers).
### 매 stat budget formula (approx.)
- **HP budget**: 매 cost × ~360 HP (King Tower level 11 baseline).
- **DPS budget**: 매 cost × ~75 DPS.
- **Range / speed / splash** 의 modifier 로 매 ±20~30% 의 adjustment.
### 매 archetype 의 cost distribution
- **Cycle deck**: 매 평균 elixir 2.6~3.0 (Hog Cycle, X-Bow 2.9).
- **Mid-range**: 매 3.4~3.8 (Royal Giant, Lavaloon).
- **Heavy**: 매 4.0+ (Three Musketeers, Mega Knight beatdown).
### 매 positive trade
- **Defender 1 elixir 우위**: 매 ideal interaction.
- **Negative trade 2+ elixir**: 매 punishable mistake.
## 💻 패턴
### Average elixir cost
```python
def avg_cost(deck):
return sum(c.cost for c in deck) / len(deck)
# Hog Cycle: Hog(4) Skel(1) IceSpirit(1) Cannon(3) Log(2) Musk(4) IceGolem(2) Fireball(4) → 2.6
```
### Stat budget audit
```python
def hp_budget_check(card):
expected = card.cost * 360
return abs(card.hp - expected) / expected < 0.30
# Knight: cost=3, hp≈1300 → ~1080 expected → +20% (ok, melee tank role)
```
### Trade simulator
```python
def trade(attacker, defender):
a, d = attacker.copy(), defender.copy()
while a.hp > 0 and d.hp > 0:
d.hp -= a.dps
a.hp -= d.dps
survivor = a if a.hp > 0 else d
return survivor, attacker.cost - defender.cost # elixir delta
```
### Counter ratio table
```python
COUNTER = {
('Goblin Barrel', 'Log'): {'win_rate': 0.95, 'elixir_gain': +1},
('Hog Rider', 'Cannon'): {'win_rate': 0.65, 'elixir_gain': +1},
('Three Musketeers', 'Fireball+Log'): {'win_rate': 0.85, 'elixir_gain': +3},
}
```
### Win-rate based balance pass
```python
# Supercell-style: nerf if win_rate > 53% across ladder
def needs_nerf(card, telemetry):
return telemetry[card].win_rate > 0.53 and telemetry[card].use_rate > 0.05
def needs_buff(card, telemetry):
return telemetry[card].win_rate < 0.47 and telemetry[card].use_rate < 0.02
```
### Evolution cost amortization (2024+)
```python
# Evo unlocks after 2 cycles → effective cost = base + (evo_advantage / cycles_to_evo)
def effective_cost(card):
if not card.has_evolution: return card.cost
return card.cost + (card.evo_power_delta / 2.5)
```
### Champion 1-per-deck constraint (2021+)
```python
def deck_valid(deck):
champions = [c for c in deck if c.is_champion]
return len(champions) <= 1
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 new card design | 매 stat budget formula → 매 baseline → 매 unique modifier |
| 매 monthly balance | 매 win-rate ±3% 의 threshold + 매 use-rate floor |
| 매 evolution rebalance | 매 cycle-amortized effective cost |
| 매 dominant deck | 매 keystone card 의 -5% HP / damage (small touch) |
**기본값**: 매 win-rate 의 47-53% band 의 maintain + 매 use-rate >2% 의 ensure (otherwise dead card).
## 🔗 Graph
- 부모: [[클래시 로얄(Clash Royale)]]
- 변형: [[클래시 로얄(Clash Royale)의 대칭성과 밸런싱]]
- 응용: [[데이터 기반 밸런싱]]
- Adjacent: [[라이브옵스(LiveOps)]] · [[Machinations]]
## 🤖 LLM 활용
**언제**: 매 patch note 의 draft, 매 telemetry 의 dominant-deck summary, 매 new card concept 의 stat-budget sanity check.
**언제 X**: 매 final balance number — 매 ladder telemetry 의 empirical 의 우월.
## ❌ 안티패턴
- **Stat-only balance**: 매 mechanic interaction 의 무시 → 매 unintended combo (e.g. Sparky + Mega Knight 2017).
- **Use-rate only**: 매 win-rate 의 무시 → 매 strong-but-niche card 의 over-buff.
- **Big-swing nerf**: 매 -20% damage 의 single change → 매 dead card.
- **Evo-blind budget**: 매 evolution power 의 cost 의 amortize 안 함 → 매 P2W perception.
## 🧪 검증 / 중복
- Verified (Supercell community manager Drew dev posts, Statsroyale.com 2024-2026 ladder data, Reddit r/ClashRoyale balance announcements).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — elixir economy + budget formula + 7 patterns |