Cognitive Psychology Series Part 4: Problem-Solving & Creativity

1. Problem-Solving Strategies

When facing a problem, your mind can deploy several strategies. The choice of strategy depends on the problem's structure, your expertise, and the available time and cognitive resources.

1.1 Algorithms vs Heuristics

The most fundamental distinction in problem-solving is between algorithms and heuristics:

Analogy: An algorithm is like following a GPS that calculates every possible route and selects the shortest one. A heuristic is like asking a local, "What's the fastest way downtown?" — usually accurate, occasionally wrong, but much faster.

1.2 Means-End Analysis

Means-end analysis is the most widely studied heuristic. It works by identifying the difference between the current state and the goal state, then selecting an operator that reduces that difference. If the operator can't be applied directly, a sub-goal is created.

# Means-End Analysis: Solving the Tower of Hanoi
# Demonstrates recursive subgoal decomposition

class TowerOfHanoi:
    """
    Classic problem-solving demonstration.
    Minimum moves = 2^n - 1 where n = number of disks.
    Requires temporarily moving AWAY from goal (counterintuitive).
    """

    def __init__(self, n_disks=3):
        self.n_disks = n_disks
        self.moves = []
        self.pegs = {
            'A': list(range(n_disks, 0, -1)),  # Source
            'B': [],                             # Auxiliary
            'C': []                              # Target
        }

    def solve(self, n=None, source='A', target='C', auxiliary='B'):
        """Recursive means-end analysis solution."""
        if n is None:
            n = self.n_disks

        if n == 1:
            self.move_disk(source, target)
            return

        # Subgoal 1: Move n-1 disks out of the way
        self.solve(n - 1, source, auxiliary, target)
        # Subgoal 2: Move the largest disk to target
        self.move_disk(source, target)
        # Subgoal 3: Move n-1 disks onto the largest
        self.solve(n - 1, auxiliary, target, source)

    def move_disk(self, source, target):
        disk = self.pegs[source].pop()
        self.pegs[target].append(disk)
        self.moves.append(f"Disk {disk}: {source} -> {target}")

    def display_solution(self):
        print(f"=== Tower of Hanoi ({self.n_disks} disks) ===")
        print(f"Minimum moves required: {2**self.n_disks - 1}")
        self.solve()
        for i, move in enumerate(self.moves, 1):
            print(f"  Step {i}: {move}")
        print(f"\nTotal moves: {len(self.moves)}")

        # Human performance comparison
        print(f"\n--- Human Performance Data ---")
        print(f"  Optimal (algorithmic): {2**self.n_disks - 1} moves")
        print(f"  Average human (3 disks): ~12 moves (vs. 7 optimal)")
        print(f"  Average human (4 disks): ~30 moves (vs. 15 optimal)")
        print(f"  Humans struggle with 'backward' moves that")
        print(f"  temporarily increase distance from the goal.")

hanoi = TowerOfHanoi(3)
hanoi.display_solution()

1.3 Trial-and-Error & Hill Climbing

Trial-and-error is the simplest problem-solving strategy: try something, see if it works, and try something else if it doesn't. Edward Thorndike's cats in puzzle boxes (1898) exemplified this approach — gradually eliminating unsuccessful responses through the law of effect.

Hill climbing is a more refined version: at each step, choose the action that moves you closest to the goal — like climbing a hill by always stepping upward. It's efficient for simple problems but can get trapped at local maxima — small peaks that aren't the true summit.

1.4 Analogical Reasoning

Analogical reasoning solves a new problem by mapping it onto a familiar one with a similar structure. It is one of the most powerful — and most human — problem-solving strategies, underlying scientific discovery, legal reasoning, and everyday problem-solving.

2. Cognitive Biases & Heuristics

Daniel Kahneman and Amos Tversky's research program, beginning in the early 1970s, demonstrated that human judgment systematically deviates from rational norms in predictable ways. Their work earned Kahneman the 2002 Nobel Prize in Economics and laid the foundation for behavioral economics.

2.1 The Availability Heuristic

The availability heuristic judges the probability of an event by how easily examples come to mind. Events that are vivid, recent, or emotionally charged feel more probable than they actually are.

2.2 The Representativeness Heuristic

The representativeness heuristic judges the probability that an item belongs to a category based on how closely it resembles a typical member of that category — ignoring base rates and statistical principles.

2.3 Anchoring & Adjustment

Anchoring occurs when an initial piece of information (the "anchor") disproportionately influences subsequent judgments, even when the anchor is arbitrary or irrelevant.

# Simulating Kahneman & Tversky's Anchoring Experiments

import random

class AnchoringExperiment:
    """
    Demonstrates how arbitrary anchors bias numerical estimates.
    Based on Tversky & Kahneman (1974) wheel-of-fortune study.
    """

    def __init__(self):
        self.true_value = 45  # True answer: % African countries in UN
        self.results = {'high_anchor': [], 'low_anchor': []}

    def simulate_participant(self, anchor):
        """
        Model: estimate = anchor + insufficient_adjustment + noise
        Humans adjust insufficiently from the anchor.
        """
        # Adjustment is typically only 30-50% of needed distance
        adjustment_ratio = random.gauss(0.4, 0.15)
        needed_adjustment = self.true_value - anchor
        actual_adjustment = needed_adjustment * adjustment_ratio
        estimate = anchor + actual_adjustment + random.gauss(0, 8)
        return max(0, min(100, estimate))

    def run(self, n_participants=200):
        high_anchor = 65  # Wheel lands on 65
        low_anchor = 10   # Wheel lands on 10

        for _ in range(n_participants):
            self.results['high_anchor'].append(
                self.simulate_participant(high_anchor))
            self.results['low_anchor'].append(
                self.simulate_participant(low_anchor))

        high_mean = sum(self.results['high_anchor']) / n_participants
        low_mean = sum(self.results['low_anchor']) / n_participants

        print("=== Anchoring Effect Simulation ===")
        print(f"True value: {self.true_value}%")
        print(f"\nHigh anchor (65): Mean estimate = {high_mean:.1f}%")
        print(f"Low anchor  (10): Mean estimate = {low_mean:.1f}%")
        print(f"Anchoring effect: {high_mean - low_mean:.1f} percentage points")
        print(f"\nOriginal K&T results: High=45%, Low=25% (20pt gap)")
        print(f"The anchor was a RANDOM spin of a wheel!")

exp = AnchoringExperiment()
exp.run()

2.4 Prospect Theory: Risk & Uncertainty

Kahneman and Tversky's Prospect Theory (1979) — arguably the most influential behavioral science paper ever published — overturned the classical economic assumption that people make rational, utility-maximizing decisions. The key findings:

3. Barriers to Problem-Solving

Sometimes the biggest obstacle to solving a problem is your own mind. Cognitive barriers — built from experience — can lock you into unproductive approaches and blind you to creative solutions.

3.1 Functional Fixedness

Functional fixedness is the tendency to see objects only in terms of their conventional uses, failing to recognize novel uses that could solve the problem at hand.

3.2 Mental Set

A mental set is the tendency to use a previously successful strategy even when simpler or more efficient alternatives exist. Once you find a method that works, your brain automates it — which is efficient until the problem changes.

3.3 Cognitive Rigidity & Confirmation Bias

Cognitive rigidity encompasses several related tendencies that keep people locked into unsuccessful approaches:

4. Insight & Creativity

Some of the most fascinating moments in human cognition occur when a problem that seemed impossible suddenly becomes obvious. This is insight — and understanding it is key to understanding creativity.

4.1 The "Aha!" Moment

Insight (also called the Eureka effect, after Archimedes' legendary bath-time discovery) is characterized by a sudden, unexpected shift in problem representation that reveals the solution. Unlike incremental problem-solving, insight feels discontinuous — you're stuck, stuck, stuck... then suddenly you see it.

Kohler's insight experiments (1917) with chimpanzees provided early evidence. Sultan, a chimpanzee, was placed in a cage with bananas hanging out of reach and two sticks — neither long enough alone. After a period of apparent frustration and inactivity, Sultan suddenly connected the two sticks and reached the bananas. This wasn't gradual trial-and-error but a sudden restructuring of the problem.

4.2 Divergent vs Convergent Thinking

J.P. Guilford's (1967) distinction between divergent and convergent thinking remains foundational to creativity research:

Key point: True creativity requires both types of thinking. Generating 100 ideas (divergent) is useless without the ability to identify the best one (convergent). The most creative individuals can flexibly switch between these modes.

# Modeling Divergent vs Convergent Thinking

import random
from collections import Counter

class CreativitySimulation:
    """
    Simulates divergent and convergent thinking processes.
    Divergent: generate many ideas via associative spreading.
    Convergent: evaluate and select the best solution.
    """

    def __init__(self):
        self.concept_network = {
            'brick': ['building', 'wall', 'weight', 'red', 'throw',
                      'doorstop', 'weapon', 'step', 'art', 'heat'],
            'building': ['house', 'tower', 'shelter', 'construct'],
            'weight': ['exercise', 'anchor', 'press', 'paperweight'],
            'red': ['paint', 'color', 'grind', 'powder', 'pigment'],
            'throw': ['projectile', 'sport', 'defense', 'break'],
            'heat': ['oven', 'warmth', 'thermal mass', 'pizza stone'],
            'art': ['sculpture', 'mosaic', 'decoration', 'garden'],
        }

    def divergent_thinking(self, prompt, depth=2):
        """
        Generate ideas by spreading activation through
        a semantic network (Alternate Uses Task).
        """
        ideas = set()
        current_nodes = [prompt]

        for level in range(depth):
            next_nodes = []
            for node in current_nodes:
                if node in self.concept_network:
                    associations = self.concept_network[node]
                    for assoc in associations:
                        ideas.add(f"Use as {assoc}")
                        next_nodes.append(assoc)
            current_nodes = next_nodes

        # Score ideas on originality (inversely related to frequency)
        scored = [(idea, random.uniform(0.1, 1.0)) for idea in ideas]
        scored.sort(key=lambda x: x[1], reverse=True)

        print(f"=== Divergent Thinking: Uses for '{prompt}' ===")
        print(f"Total ideas generated: {len(scored)}")
        print(f"\nTop 10 by originality score:")
        for idea, score in scored[:10]:
            bar = "█" * int(score * 20)
            print(f"  {score:.2f} {bar} {idea}")

        return scored

    def convergent_thinking(self, ideas, criteria):
        """Evaluate ideas against criteria to select the best."""
        print(f"\n=== Convergent Thinking: Evaluating {len(ideas)} Ideas ===")
        print(f"Criteria: {', '.join(criteria)}")

        # Score each idea against multiple criteria
        evaluated = []
        for idea, originality in ideas[:10]:
            feasibility = random.uniform(0.3, 1.0)
            usefulness = random.uniform(0.2, 1.0)
            total = (originality + feasibility + usefulness) / 3
            evaluated.append((idea, total, originality, feasibility))

        evaluated.sort(key=lambda x: x[1], reverse=True)
        print(f"\nBest solution: {evaluated[0][0]} (score: {evaluated[0][1]:.2f})")
        return evaluated[0]

sim = CreativitySimulation()
ideas = sim.divergent_thinking('brick')
sim.convergent_thinking(ideas, ['originality', 'feasibility', 'usefulness'])

4.3 Creative Cognition & Innovation Psychology

The creative cognition approach (Finke, Ward, & Smith, 1992) argues that creativity emerges from ordinary cognitive processes — memory retrieval, conceptual combination, analogical mapping — applied in extraordinary ways. There is no special "creativity module" in the brain.

Wallas's Four-Stage Model (1926) remains influential:

1. Preparation: Immerse yourself in the problem domain; gather information
2. Incubation: Set the problem aside; unconscious processing continues
3. Illumination: The "aha!" moment — the solution suddenly appears
4. Verification: Test and refine the solution; ensure it actually works

5. Expert vs Novice Cognition

One of the most consistent findings in cognitive psychology is that experts and novices don't just know different amounts — they think differently. Understanding these differences has profound implications for education, training, and artificial intelligence.

5.1 Expert Knowledge Structures

5.2 Computational Models of Problem-Solving

Computational models formalize theories of problem-solving as runnable programs, allowing precise predictions and testing:

# Simple Production System Model (inspired by ACT-R/SOAR)
# Demonstrates how experts use pattern-matched rules

class ProductionSystem:
    """
    A simplified production system for problem categorization.
    Experts have rules that match deep structure;
    novices have rules that match surface features.
    """

    def __init__(self, expertise_level='novice'):
        self.expertise = expertise_level
        self.working_memory = []

        if expertise_level == 'expert':
            self.productions = [
                {'condition': 'energy_conservation',
                 'action': 'Apply conservation of energy: KE + PE = constant',
                 'trigger_features': ['height', 'velocity', 'mass',
                                      'no friction']},
                {'condition': 'newtons_second_law',
                 'action': 'Apply F=ma; identify all forces',
                 'trigger_features': ['force', 'acceleration', 'mass',
                                      'net force']},
                {'condition': 'work_energy',
                 'action': 'Apply W = Fd; relate to kinetic energy',
                 'trigger_features': ['distance', 'force', 'velocity change']},
            ]
        else:
            self.productions = [
                {'condition': 'inclined_plane',
                 'action': 'Look for incline formulas',
                 'trigger_features': ['ramp', 'slope', 'angle', 'incline']},
                {'condition': 'spring_problem',
                 'action': 'Look for spring formulas',
                 'trigger_features': ['spring', 'compress', 'stretch']},
                {'condition': 'pulley_problem',
                 'action': 'Look for pulley formulas',
                 'trigger_features': ['pulley', 'rope', 'tension']},
            ]

    def categorize_problem(self, problem_features):
        """Match problem features against production rules."""
        print(f"\n--- {self.expertise.upper()} categorization ---")
        print(f"Problem features: {problem_features}")

        best_match = None
        best_score = 0

        for prod in self.productions:
            matches = sum(1 for f in prod['trigger_features']
                         if f in problem_features)
            if matches > best_score:
                best_score = matches
                best_match = prod

        if best_match:
            print(f"Category: {best_match['condition']}")
            print(f"Strategy: {best_match['action']}")
            print(f"Match confidence: {best_score}/{len(problem_features)}")
        return best_match

# Problem: Ball rolling down a ramp (no friction)
problem = ['ramp', 'height', 'velocity', 'mass', 'no friction']

novice = ProductionSystem('novice')
expert = ProductionSystem('expert')

novice.categorize_problem(problem)  # "inclined_plane" (surface)
expert.categorize_problem(problem)  # "energy_conservation" (deep)

Exercises & Self-Assessment

Conclusion & Next Steps

In this exploration of problem-solving and creativity, we've journeyed from systematic algorithms to fallible heuristics, from cognitive barriers to creative breakthroughs. Here are the key takeaways:

• Problem-solving is search through a problem space — but humans use heuristics rather than exhaustive algorithms, trading guaranteed accuracy for speed
• Cognitive biases are systematic: Availability, representativeness, and anchoring heuristics create predictable errors that affect everyone, from students to Supreme Court justices
• Prospect theory reveals that decisions are driven by losses and gains relative to a reference point, not by absolute outcomes — explaining risk aversion, the framing effect, and the sunk cost fallacy
• Functional fixedness and mental set show how past experience can become a prison, preventing us from seeing simple solutions
• Insight involves restructuring, not incremental progress — and can be facilitated by incubation, diverse experience, and techniques that break functional fixedness
• Creativity requires both divergent and convergent thinking — generating many ideas and then rigorously evaluating them
• Experts think differently from novices, categorizing problems by deep structure rather than surface features and using forward reasoning from principles