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

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-innovative-problem-solving	Innovative Problem Solving	10_Wiki/Topics	verified	self	innovation TRIZ lateral thinking design thinking first principles	none	A	0.85	applied	innovation problem-solving triz lateral-thinking design-thinking creativity		2026-05-10	pending	language applicable_to Methodology 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)

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)

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

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

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

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

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

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

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)

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

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

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)

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

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
• 변형: TRIZ · Design Thinking · First-Principles
• 응용: Innovation
• Adjacent: 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