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

에이전트 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>
2026-07-11 11:05:56 +09:00
parent 6549ead309
commit c24165b8bc
6193 changed files with 1717 additions and 31 deletions
@@ -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 정리 |