2nd/10_Wiki/Topics/AI_and_ML/Innovative Problem Solving.md

---
id: wiki-2026-0508-innovative-problem-solving
title: Innovative Problem Solving
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [innovation, TRIZ, lateral thinking, design thinking, first principles]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [innovation, problem-solving, triz, lateral-thinking, design-thinking, creativity]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: Methodology
  applicable_to: [Engineering, Product, Strategy]
---

# Innovative Problem Solving

## 매 한 줄
> **"매 conventional 의 의 X — 매 lateral / first principles / structured creativity"**. 매 TRIZ (Altshuller), 매 Design Thinking (IDEO), 매 First Principles (Musk-style), 매 SCAMPER, 매 6 Thinking Hats. 매 modern: 매 LLM 의 의 의 brainstorm partner.

## 매 핵심

### 매 framework
- **TRIZ** (40 inventive principles).
- **Design Thinking**: empathize, define, ideate, prototype, test.
- **First Principles** (physics-style decompose).
- **SCAMPER**: Substitute, Combine, Adapt, Modify, Put to other use, Eliminate, Reverse.
- **6 Thinking Hats** (de Bono).
- **Lateral Thinking** (de Bono).
- **Lean Startup**: build-measure-learn.

### 매 응용
1. Engineering.
2. Product design.
3. Strategy.
4. Conflict resolution.
5. R&D.

## 💻 패턴

### TRIZ (40 principles)
```python
TRIZ_PRINCIPLES = {
    1: 'Segmentation',
    2: 'Taking out',
    3: 'Local quality',
    13: 'The other way around',
    35: 'Parameter changes',
    40: 'Composite materials',
    # ... 40 total
}

def triz_assist(contradiction, llm):
    prompt = f"""Apply TRIZ. Contradiction: {contradiction}
Suggest 3 principles + concrete application."""
    return llm.generate(prompt)
```

### First principles (Musk-style)
```python
def first_principles_decompose(problem, llm):
    prompt = f"""First principles thinking on: {problem}

1. What are the fundamental truths/constraints?
2. What does each fundamental cost / require?
3. What new combinations are possible?
4. What's the minimum viable approach?"""
    return llm.generate(prompt)
```

### SCAMPER
```python
SCAMPER = {
    'S': 'Substitute — what can replace?',
    'C': 'Combine — what can merge?',
    'A': 'Adapt — what from elsewhere?',
    'M': 'Modify — bigger / smaller / different?',
    'P': 'Put to other use',
    'E': 'Eliminate — what to remove?',
    'R': 'Reverse — opposite?',
}

def scamper(idea, llm):
    return {k: llm.generate(f'{v}\nIdea: {idea}') for k, v in SCAMPER.items()}
```

### 6 Thinking Hats
```python
HATS = {
    'white': 'facts only',
    'red': 'emotions / intuition',
    'black': 'risks / criticism',
    'yellow': 'benefits / optimism',
    'green': 'creative / new ideas',
    'blue': 'process / control',
}

def six_hats(problem, llm):
    return {color: llm.generate(f'As {color} hat ({mode}): {problem}') for color, mode in HATS.items()}
```

### Design Thinking phases
```python
def design_thinking(problem):
    return {
        'empathize': '5 user interviews + observation',
        'define': 'How might we... statement',
        'ideate': '20 ideas in 30 min, defer judgment',
        'prototype': 'low-fi paper / digital mock',
        'test': '5 user tests + iterate',
    }
```

### Reverse the problem
```python
def reverse_problem(original_problem, llm):
    return llm.generate(f"""Take the opposite/reverse:

Problem: {original_problem}
Reverse: How would I make this problem WORSE?

Then: invert each "make worse" → potential solution.""")
```

### Analogical reasoning
```python
def analogy(problem, llm, domains=['biology', 'physics', 'history']):
    analogies = {}
    for domain in domains:
        analogies[domain] = llm.generate(f"""Find analog in {domain} for: {problem}
Apply principles from that domain.""")
    return analogies
```

### Constraint relaxation
```python
def relax_constraints(problem, llm):
    return llm.generate(f"""For: {problem}

List current constraints. For each, ask:
- Is this REALLY a constraint?
- What if I relaxed it?
- What new solutions become possible?""")
```

### 5 Why (root cause)
```python
def five_whys(symptom, llm):
    why_chain = [symptom]
    for _ in range(5):
        next_why = llm.generate(f'Why does {why_chain[-1]} happen? Single cause.')
        why_chain.append(next_why)
    return why_chain
```

### Brainstorm rules
```python
BRAINSTORM_RULES = [
    "Defer judgment",
    "Build on others' ideas (yes-and)",
    "Aim for quantity",
    "Encourage wild ideas",
    "Stay focused on topic",
    "One conversation at a time",
    "Be visual",
]
```

### LLM-paired ideation
```python
def llm_brainstorm(problem, llm, n_ideas=20):
    ideas = []
    for _ in range(n_ideas):
        idea = llm.generate(f"""Brainstorming on: {problem}
Previous ideas: {ideas}
Generate ONE NEW different idea (avoid repeats).""", temperature=1.0)
        ideas.append(idea)
    return ideas
```

### Pre-mortem (fail-mode)
```python
def pre_mortem(plan, llm):
    return llm.generate(f"""Imagine 1 year from now this plan failed.
Plan: {plan}

Write the obituary. What went wrong?
Now: how do we prevent each cause?""")
```

### Constraint-based creativity
```python
def constrained_creativity(problem, constraint, llm):
    """매 constraint 의 의 forces creativity."""
    return llm.generate(f"""Solve: {problem}
But you MUST: {constraint}

Examples of forced constraints:
- 'No money'
- 'Half the time'
- 'Reverse the typical approach'
- 'Use only 3 elements'""")
```

## 매 결정 기준
| 상황 | Method |
|---|---|
| Engineering contradiction | TRIZ |
| Cost / fundamental rethink | First principles |
| Product | Design Thinking |
| Quick brainstorm | SCAMPER / Hats |
| Stuck | Reverse / analogy / constraint relax |
| Risk | Pre-mortem |

**기본값**: 매 First principles + LLM brainstorm + SCAMPER + pre-mortem. 매 매 single tool 의 over-rely X.

## 🔗 Graph
- 부모: [[Creativity]] · [[Problem_Solving|Problem-Solving]]
- 변형: [[TRIZ]] · [[Design Thinking]] · [[First-Principles]]
- 응용: [[Innovation]]
- Adjacent: [[Computational_Creativity|Computational-Creativity]] · [[Iterative Prompting]] · [[GAME_SYSTEM_DESIGN_PROMPT]]

## 🤖 LLM 활용
**언제**: 매 stuck. 매 brainstorm partner.
**언제 X**: 매 well-defined narrow.

## ❌ 안티패턴
- **Single method dogma**: 매 tool fits.
- **No constraint**: 매 unfocused.
- **Skip pre-mortem**: 매 risk blind.
- **Brainstorm without rules**: 매 group-think.

## 🧪 검증 / 중복
- Verified (Altshuller TRIZ, IDEO Design Thinking, de Bono).
- 신뢰도 B+.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — methods + 매 TRIZ / first principles / SCAMPER / hats / pre-mortem code |