Problem Solving in Cognitive Psychology: Strategies for Complex Reasoning

Last Updated May 20, 2026

Problem solving refers to the cognitive processes through which individuals identify goals, represent problems, generate strategies, monitor progress, and evaluate solutions in situations where an answer is not immediately available. In cognitive psychology, problem solving is one of the clearest expressions of flexible, goal-directed thought. It requires the coordination of perception, attention, working memory, long-term memory, reasoning, metacognition, strategy selection, and feedback-based adaptation in order to move from a current state to a desired one under conditions of uncertainty, constraint, or incomplete information.

Problem solving is central to cognition because it allows individuals to move beyond routine response and engage in adaptive behavior when no ready-made answer is available. In complex environments, this requires more than information alone. It requires the capacity to structure a problem, decide what matters, generate candidate paths, evaluate alternatives, revise strategy, and learn from failure. A person does not merely react to a problem; they construct a representation of it, and that representation shapes the space of possible solutions.

These demands draw on multiple cognitive systems, including attention, working memory, memory, metacognition, mental models, analogical reasoning, insight and creative problem solving, and decision making. Problem solving therefore offers one of the best windows into cognition as an organized system rather than a collection of isolated functions.

Problem solving matters because many of the most consequential human tasks do not arrive as neatly defined puzzles. They arrive as ambiguous situations: a medical diagnosis, a design failure, a public-policy dilemma, a scientific anomaly, an organizational breakdown, a legal dispute, a technical bug, a financial decision, or an educational challenge. In these settings, the problem itself must often be discovered before it can be solved.

The structure of problem solving

Problem solving can be understood as a structured process involving several recurring cognitive operations. These operations do not always occur in a fixed linear order, but they help describe what the mind must do when no immediate answer is available.

• Problem detection, where the individual recognizes that a current state differs from a desired state.
• Problem representation, where relevant information, goals, constraints, and possible operators are encoded.
• Strategy generation, where possible routes to solution are developed.
• Strategy selection, where one or more approaches are chosen based on expected usefulness, effort, familiarity, and risk.
• Implementation, where the chosen strategy is executed.
• Monitoring, where progress, error, and uncertainty are evaluated.
• Revision, where the solver adjusts representation or strategy when progress stalls.
• Learning, where outcomes are incorporated into future problem-solving knowledge.

The way a problem is represented strongly influences what strategies seem possible. A poor representation can make a solvable problem look impossible, while a well-structured representation can reveal useful constraints, hidden analogies, and efficient paths to solution. In many cases, the most important step is not applying a known procedure, but building a better representation of the task.

This is why problem solving is not merely about choosing among ready-made options. It often begins with seeing the problem correctly in the first place. A student may fail at a mathematics problem because they encode it as a formula-recall task rather than a relational task. A physician may miss a diagnosis because the case is represented through the wrong category. A policy team may fail because it frames a systemic issue as an individual-behavior problem.

Problem solving is therefore both a search process and a representation process. Search matters because solutions require movement through possible states. Representation matters because the search space itself depends on how the problem is understood.

Back to top ↑

Problem representation and mental models

Effective problem solving depends on how individuals represent problems internally. These representations often take the form of mental models, which organize information into structured frameworks that can be inspected, manipulated, revised, and tested.

A mental model of a problem may include:

• the current state;
• the desired goal state;
• the difference between current and goal states;
• constraints that limit action;
• operators or moves that may change the state;
• causal relations among variables;
• feedback signals that indicate progress or error;
• assumptions about what matters and what can be ignored.

Mental models allow individuals to simulate possible outcomes, identify constraints, and explore alternative solutions without testing every option directly in the world. They transform abstract or confusing situations into more manageable representations. A diagram, table, sketch, equation, map, story, analogy, or prototype can all function as an externalized mental model that helps distribute cognitive work.

This connection is important because many problem-solving failures are not failures of effort but failures of representation. When the internal model is incomplete, rigid, misleading, or poorly matched to the actual structure of the problem, the solution path is often distorted from the start. A solver may work diligently while moving in the wrong direction.

Representation also explains why reframing can be powerful. A difficult problem may become easier when it is decomposed into subproblems, represented visually, translated into a different notation, compared to a prior case, or reframed around a different goal. The facts may not change, but the cognitive structure through which they are processed changes dramatically.

Problem representation is therefore not a preliminary step that happens before “real” solving begins. It is part of the solution process itself.

Back to top ↑

Strategies for problem solving

Cognitive psychology identifies several major strategies used in problem solving. Each strategy involves trade-offs among accuracy, efficiency, cognitive effort, flexibility, and risk.

• Algorithmic strategies use step-by-step procedures that guarantee a solution when correctly applied to an appropriate problem. They are reliable but may be slow or computationally costly.
• Heuristic strategies use simplified rules that reduce effort but do not guarantee optimal solutions. They are often efficient but can produce systematic error.
• Means–end analysis reduces the difference between the current state and the goal state by selecting operators that appear to move the solver closer to the desired outcome.
• Decomposition breaks a large problem into smaller subproblems that can be solved or managed separately.
• Analogical reasoning applies knowledge from structurally similar problems to new situations.
• Insight-based restructuring changes the representation of a problem so that a previously hidden solution becomes visible.
• Trial-and-error search explores possible actions through feedback when prior knowledge or structure is limited.

No strategy is universally best. Algorithmic strategies are powerful when the problem is well defined and the correct procedure is known. Heuristics are useful when information is incomplete or time is limited. Analogy is powerful when structural similarity is correctly recognized. Insight matters when the existing representation blocks solution. Decomposition is essential when the problem is too complex to hold as a single whole.

Strategy choice is itself a cognitive problem. Solvers must decide whether to persist, switch, decompose, search, ask for help, use a tool, look for an analogy, or reframe the problem. This choice depends on task structure, prior experience, working-memory demands, perceived effort, feedback, and metacognitive monitoring.

The existence of multiple strategies shows that problem solving is not a single uniform process. It is a family of cognitive approaches selected in light of task structure, available knowledge, and processing constraints.

Back to top ↑

Formalizing problem solving: states, search, and strategy

Problem solving can be formalized as movement through a problem space. Let the current state of the problem be \(s_t\), the goal state be \(g\), and the set of available operators be \(O\). A problem-solving process can be described as selecting actions that transform one state into another:

Means–end analysis can be represented by minimizing the distance between current and goal states:

The probability of selecting a strategy \(k\) can also be represented as a function of expected usefulness, effort cost, and prior familiarity:

One can also express problem-solving error in terms of representational mismatch:

Finally, total problem-solving burden can be represented as the combined load of difficulty, constraints, memory, and uncertainty:

These formalizations are useful because they clarify why problem solving can fail in different ways. The solver may choose poor operators, rely on the wrong strategy, misrepresent the goal, overload working memory, or search a problem space that was incorrectly constructed from the start.

Back to top ↑

Problem solving and working memory

Working memory plays a critical role in problem solving because it maintains relevant information, intermediate results, constraints, and partial plans while a solution is being constructed. Complex problems often place heavy demands on working memory, limiting how many elements can be coordinated simultaneously.

This limitation helps explain why difficult problems feel cognitively expensive and why people often use heuristics, diagrams, notes, outlines, equations, checklists, prototypes, or external tools to reduce internal burden. External representation is not a sign of weak cognition; it is one of the ways cognition becomes more powerful. A notebook, spreadsheet, whiteboard, simulation, or diagram can extend working memory by preserving structure outside the mind.

Working-memory load becomes especially important when a problem requires:

• tracking multiple variables at once;
• maintaining subgoals while pursuing a larger goal;
• comparing alternative strategies;
• remembering constraints while generating solutions;
• evaluating delayed consequences;
• integrating feedback across time;
• avoiding distraction and irrelevant information.

High working-memory load can push solvers toward simpler heuristics, premature closure, or repeated use of familiar strategies even when those strategies are not effective. Conversely, better representations and domain expertise can reduce working-memory burden by chunking information into meaningful structures.

Problem solving is therefore one of the clearest domains in which working-memory limits become practically visible. The quality of a solution often depends not only on intelligence or motivation, but on whether the solver can maintain the relevant structure long enough to reason through it.

Back to top ↑

Attention, constraint, and search control

Attention determines what aspects of a problem are selected for processing. In problem solving, attention must be allocated among goals, constraints, cues, possible actions, feedback, errors, and irrelevant distractions. What the solver attends to shapes what the problem becomes.

In well-structured problems, attention may be guided by clear rules and feedback. In ill-structured problems, attention must be organized more actively. The solver must decide which variables matter, which constraints are real, which signals indicate progress, and which details are noise. This makes attention a central part of search control.

Attentional control helps solvers:

• focus on relevant constraints;
• avoid distraction from irrelevant surface features;
• detect patterns in feedback;
• notice contradictions or anomalies;
• shift away from an unproductive strategy;
• recognize when a hidden assumption should be questioned.

Problem solving can fail when attention becomes too narrow or too diffuse. Narrow attention may produce fixation, where the solver repeats a familiar approach despite poor results. Diffuse attention may prevent systematic progress because too many alternatives remain active. Effective problem solving requires both focus and flexibility: the ability to maintain direction while still noticing when direction should change.

This is especially important in complex real-world environments. A physician, engineer, teacher, policymaker, researcher, or manager may not fail because they lack information. They may fail because attention is misallocated by urgency, institutional pressure, misleading metrics, incomplete feedback, or inherited assumptions about what kind of problem they are facing.

Back to top ↑

Metacognition and strategy selection

Metacognition plays a major role in successful problem solving because individuals must do more than execute strategies. They must also monitor whether those strategies are working, evaluate progress, and decide when to persist, switch, pause, seek help, or reframe the task.

Effective problem solvers often:

• notice when they are stuck;
• judge whether their current strategy is productive;
• evaluate whether the problem representation is adequate;
• switch approaches when necessary;
• distinguish confidence from correctness;
• use feedback to revise plans;
• reflect on what can be learned from failure.

This ability to regulate cognition helps distinguish effective from ineffective problem solving. A solver who monitors progress well may abandon a poor strategy before wasting too much effort. A solver with weak monitoring may continue searching the wrong problem space because effort is mistaken for progress.

Metacognition is also central to strategy selection. People do not simply choose the objectively best strategy. They choose strategies based on perceived usefulness, effort, familiarity, confidence, and available time. These perceptions can be accurate or distorted. A familiar heuristic may feel easy but produce errors. A slower decomposition strategy may feel burdensome but improve accuracy. A solver may avoid a difficult but necessary representation shift because it requires admitting that the initial framing was wrong.

Strong metacognition makes problem solving more adaptive. It turns problem solving into a self-regulating process rather than a fixed sequence of moves.

Back to top ↑

Problem solving under uncertainty

Many real-world problems involve uncertainty, incomplete information, shifting conditions, hidden variables, multiple goals, feedback delays, and dynamic consequences. In such environments, individuals cannot evaluate every possible state or know in advance which solution path will succeed.

This requires problem solving to interact closely with decision making. Under uncertainty, people must choose strategies before outcomes are fully known, balance exploration against commitment, update beliefs from feedback, and often rely on prior knowledge or heuristics to move forward.

Uncertain problem solving differs from routine puzzle solving in several ways:

• the goal may be ambiguous or contested;
• the problem may change while the solver acts;
• feedback may be delayed, weak, or misleading;
• multiple stakeholders may define success differently;
• some variables may be hidden;
• solutions may create new problems;
• there may be no single correct answer.

These conditions help explain why real-world problem solving is often open-ended, adaptive, and only partly specifiable in advance. A public health crisis, infrastructure failure, organizational conflict, climate-risk problem, or educational inequity problem cannot be solved as if it were a closed laboratory puzzle. The solver must learn while acting.

Under uncertainty, good problem solving requires humility. It requires treating early representations as provisional, using feedback carefully, preserving alternative hypotheses, and recognizing when confidence is unsupported by evidence.

Back to top ↑

Insight, analogy, and restructuring

Some problems cannot be solved efficiently by continuing the same search. They require a change in representation. This is where insight and creative problem solving become central. Insight occurs when a problem is restructured so that a previously hidden solution becomes visible.

Insight often follows impasse. The solver tries familiar moves, fails, and then must loosen constraints or reinterpret the problem. A solution may then emerge suddenly, not because reasoning stopped, but because the structure of reasoning changed.

Analogical reasoning can support this process by bringing in structure from another domain. A new problem may become solvable when it is recognized as structurally similar to an old problem. Analogy can suggest operators, constraints, causal relations, or solution paths that were not visible in the original framing.

Restructuring can occur through:

• constraint relaxation, where an assumed limitation is dropped;
• re-encoding, where problem elements are interpreted differently;
• analogy, where a source structure is mapped onto the target;
• decomposition, where a large problem is broken into meaningful subproblems;
• external representation, where diagrams or models reveal relations hidden in verbal form;
• incubation, where a break reduces fixation and allows new associations to emerge.

Problem solving therefore depends not only on persistence, but on flexible persistence. Continuing effort is useful when the representation is sound. When the representation is wrong, progress may require stepping back and changing the map.

Back to top ↑

Learning and expertise in problem solving

Problem-solving ability often improves with experience. Experts tend to develop more effective mental models, recognize meaningful patterns more quickly, and apply strategies more efficiently than novices. They often see structure where novices see surface detail.

This progression reflects broader principles of skill acquisition. As knowledge becomes better organized, experts rely less on brute-force search and more on structured recognition, domain-specific inference, and efficient strategy selection. A chess master does not evaluate the board as isolated pieces. A physician does not treat every symptom as disconnected. An engineer does not see a failure as only an event; they see relations among materials, loads, systems, and constraints.

Expertise improves problem solving by enabling:

• better problem representation;
• faster recognition of meaningful patterns;
• larger and more useful chunks in memory;
• more efficient retrieval of prior cases;
• better strategy selection;
• more accurate error detection;
• stronger metacognitive monitoring.

Expertise can also create risk. Experts may become fixated on familiar categories, overlook anomalies, or apply a known solution too quickly to a structurally different problem. Novices may fail because they lack structure; experts may fail because their structure becomes too rigid.

Effective expertise therefore combines knowledge with flexibility. The expert problem solver knows not only what to do, but when the usual way of doing it no longer fits.

Back to top ↑

Complex and real-world problem solving

Complex problem solving differs from simple problem solving because the environment itself may be dynamic, uncertain, and partially opaque. The solver may face multiple goals, hidden variables, delayed feedback, interacting subsystems, and consequences that unfold over time.

Complex problems often have several features:

• dynamic change, where the system changes as the solver acts;
• interdependence, where variables influence one another;
• opacity, where important causes are hidden;
• multiple goals, where objectives conflict or trade off;
• delayed feedback, where consequences appear later;
• irreversibility, where some actions cannot be easily undone;
• social embeddedness, where stakeholders have different knowledge and interests.

These features make complex problem solving a major concern for education, governance, engineering, sustainability, healthcare, public administration, organizational strategy, and technology design. In such settings, the challenge is not only to find a correct answer, but to construct a workable approach under uncertainty.

Real-world problem solving often requires systems thinking. A symptom may not reveal the underlying cause. A local fix may create a system-wide failure. A short-term success may increase long-term risk. A decision that appears rational for one actor may be harmful across the broader system.

Cognitive psychology contributes by showing that complexity is not only “out there” in the world. It is also cognitively mediated. People must represent complexity, attend to relevant variables, remember constraints, reason through feedback, and adapt strategy. A complex system becomes solvable only when it becomes cognitively tractable without being falsely simplified.

Back to top ↑

Problem solving and artificial intelligence

Problem solving has been central to artificial intelligence from the beginning. Classical AI treated intelligence partly as search through problem spaces, using symbolic representations, operators, goals, and heuristic guidance. Newell and Simon’s work on human problem solving helped shape a tradition in which cognition could be modeled as information processing, search, and symbolic manipulation.

Contemporary AI expands this landscape. Search algorithms, planning systems, reinforcement learning, constraint solvers, theorem provers, case-based reasoning systems, large language models, tool-using agents, and hybrid architectures all participate in problem-solving research. These systems differ from human cognition in important ways, but they raise parallel questions about representation, search, strategy, feedback, uncertainty, and evaluation.

AI can support human problem solving by:

• organizing information;
• generating candidate strategies;
• searching large spaces;
• simulating outcomes;
• identifying patterns;
• retrieving analogies or prior cases;
• supporting explanation and documentation;
• reducing some forms of cognitive load.

But AI can also create new problem-solving risks. Systems may produce plausible but incorrect suggestions, hide uncertainty, reinforce poor representations, or lead users to overtrust generated answers. Human-AI problem solving therefore requires calibrated trust, clear provenance, interpretable reasoning support, and human responsibility for evaluation.

The cognitive question is not whether machines can solve problems. It is how human and artificial problem-solving systems should be integrated so that representation, search, strategy, and accountability remain visible enough to be governed.

Back to top ↑

Problem solving in contemporary research

Modern research on problem solving integrates cognitive psychology, developmental psychology, neuroscience, artificial intelligence, education, human factors, organizational research, and complex-systems science. Newell and Simon’s Human Problem Solving remains one of the foundational landmarks because it framed problem solving in terms of information processing, search, and symbolic structure rather than vague general intelligence.

Developmental research shows that problem solving has early roots. Children gradually develop the ability to coordinate perception, action, planning, tool use, goal representation, and feedback. This makes problem solving not merely an adult reasoning skill but a fundamental developmental achievement.

Contemporary complex problem-solving research has also shifted attention toward dynamic environments, uncertainty, hidden variables, delayed feedback, and multiple interacting goals. This broadened focus matters because many important problems in real life are not closed-form puzzles. They unfold over time and must be solved while the environment changes.

Current research therefore treats problem solving as a multi-layered cognitive process involving representation, strategy selection, working memory, feedback, metacognition, learning, social context, and tools. The field increasingly asks not only how people solve defined problems, but how they define problems in the first place.

Back to top ↑

R code for problem-solving data

The following R workflow illustrates analyses relevant to problem-solving research, including strategy use, solution accuracy, solution quality, working-memory effects, problem difficulty, strategy switching, insight events, and response time.

# Install packages if needed:
# pak::pak(c("tidyverse", "lme4", "lmerTest", "emmeans", "broom.mixed"))

library(tidyverse)
library(lme4)
library(lmerTest)
library(emmeans)
library(broom.mixed)

# Expected columns:
# participant, condition, problem_id, strategy_type,
# problem_difficulty, representation_quality, goal_clarity,
# constraint_load, wm_load, metacognitive_monitoring,
# strategy_switch_count, switched_strategy, insight_event,
# solution_accuracy, solution_quality, error_count,
# confidence, response_time_ms

dat <- read_csv("problem_solving_trials.csv") %>%
  mutate(
    participant = factor(participant),
    condition = factor(condition),
    problem_id = factor(problem_id),
    strategy_type = factor(strategy_type),
    switched_strategy = as.integer(switched_strategy),
    insight_event = as.integer(insight_event),
    solution_accuracy = as.integer(solution_accuracy),
    log_response_time = log(response_time_ms)
  )

# -----------------------------
# 1. Descriptive profile
# -----------------------------

condition_summary <- dat %>%
  group_by(condition) %>%
  summarise(
    n_trials = n(),
    participants = n_distinct(participant),
    mean_difficulty = mean(problem_difficulty, na.rm = TRUE),
    mean_representation = mean(representation_quality, na.rm = TRUE),
    mean_goal_clarity = mean(goal_clarity, na.rm = TRUE),
    mean_constraint_load = mean(constraint_load, na.rm = TRUE),
    mean_wm_load = mean(wm_load, na.rm = TRUE),
    mean_metacognition = mean(metacognitive_monitoring, na.rm = TRUE),
    switch_rate = mean(switched_strategy, na.rm = TRUE),
    mean_switch_count = mean(strategy_switch_count, na.rm = TRUE),
    insight_rate = mean(insight_event, na.rm = TRUE),
    accuracy_rate = mean(solution_accuracy, na.rm = TRUE),
    mean_solution_quality = mean(solution_quality, na.rm = TRUE),
    mean_errors = mean(error_count, na.rm = TRUE),
    mean_confidence = mean(confidence, na.rm = TRUE),
    mean_response_time_ms = mean(response_time_ms, na.rm = TRUE),
    .groups = "drop"
  )

print(condition_summary)

# -----------------------------
# 2. Solution-accuracy model
# -----------------------------

accuracy_model <- glmer(
  solution_accuracy ~
    condition +
    strategy_type +
    problem_difficulty +
    representation_quality +
    goal_clarity +
    constraint_load +
    wm_load +
    metacognitive_monitoring +
    switched_strategy +
    insight_event +
    (1 | participant) +
    (1 | problem_id),
  data = dat,
  family = binomial(),
  control = glmerControl(optimizer = "bobyqa")
)

summary(accuracy_model)
emmeans(accuracy_model, ~ condition, type = "response")
emmeans(accuracy_model, ~ strategy_type, type = "response")

# -----------------------------
# 3. Strategy-switch model
# -----------------------------

switch_model <- glmer(
  switched_strategy ~
    condition +
    problem_difficulty +
    representation_quality +
    constraint_load +
    wm_load +
    metacognitive_monitoring +
    (1 | participant) +
    (1 | problem_id),
  data = dat,
  family = binomial(),
  control = glmerControl(optimizer = "bobyqa")
)

summary(switch_model)

# -----------------------------
# 4. Solution-quality model
# -----------------------------

quality_model <- lmer(
  solution_quality ~
    condition +
    strategy_type +
    problem_difficulty +
    representation_quality +
    goal_clarity +
    constraint_load +
    wm_load +
    metacognitive_monitoring +
    insight_event +
    solution_accuracy +
    error_count +
    (1 | participant) +
    (1 | problem_id),
  data = dat,
  REML = FALSE
)

summary(quality_model)
emmeans(quality_model, ~ condition)

# -----------------------------
# 5. Response-time model
# -----------------------------

rt_model <- lmer(
  log_response_time ~
    condition +
    strategy_type +
    problem_difficulty +
    representation_quality +
    constraint_load +
    wm_load +
    strategy_switch_count +
    solution_accuracy +
    (1 | participant) +
    (1 | problem_id),
  data = dat,
  REML = FALSE
)

summary(rt_model)

# -----------------------------
# 6. Error-count model
# -----------------------------

error_model <- glmer(
  error_count ~
    condition +
    strategy_type +
    problem_difficulty +
    representation_quality +
    constraint_load +
    wm_load +
    metacognitive_monitoring +
    (1 | participant) +
    (1 | problem_id),
  data = dat,
  family = poisson(),
  control = glmerControl(optimizer = "bobyqa")
)

summary(error_model)

# -----------------------------
# 7. Visualization
# -----------------------------

ggplot(dat, aes(x = representation_quality, y = solution_quality, color = strategy_type)) +
  geom_point(alpha = 0.25) +
  geom_smooth(method = "lm", se = FALSE) +
  labs(
    title = "Problem representation and solution quality",
    x = "Representation quality",
    y = "Solution quality"
  ) +
  theme_minimal()

This workflow can be adapted for strategy-comparison experiments, expert-novice studies, working-memory-load manipulations, problem-representation interventions, insight-versus-analytic problem comparisons, dynamic problem-solving simulations, or human-AI decision-support studies. Researchers should model participant and problem effects whenever possible because problem-solving tasks often vary strongly in difficulty, representation demands, and prior familiarity.

Back to top ↑

Python code for problem-solving data

The Python examples below parallel the R workflow and are useful for strategy-comparison studies, working-memory effects, adaptive problem-solving experiments, response-time modeling, error analysis, and solution-quality evaluation.

import numpy as np
import pandas as pd
import statsmodels.formula.api as smf
import statsmodels.api as sm
import matplotlib.pyplot as plt

# Expected columns:
# participant, condition, problem_id, strategy_type,
# problem_difficulty, representation_quality, goal_clarity,
# constraint_load, wm_load, metacognitive_monitoring,
# strategy_switch_count, switched_strategy, insight_event,
# solution_accuracy, solution_quality, error_count,
# confidence, response_time_ms

df = pd.read_csv("problem_solving_trials.csv")

categorical_cols = ["participant", "condition", "problem_id", "strategy_type"]
for col in categorical_cols:
    df[col] = df[col].astype("category")

df["switched_strategy"] = df["switched_strategy"].astype(int)
df["insight_event"] = df["insight_event"].astype(int)
df["solution_accuracy"] = df["solution_accuracy"].astype(int)
df["log_response_time"] = np.log(df["response_time_ms"])

# -----------------------------
# 1. Descriptive profile
# -----------------------------

condition_summary = (
    df.groupby("condition")
    .agg(
        n_trials=("solution_accuracy", "size"),
        participants=("participant", "nunique"),
        mean_difficulty=("problem_difficulty", "mean"),
        mean_representation=("representation_quality", "mean"),
        mean_goal_clarity=("goal_clarity", "mean"),
        mean_constraint_load=("constraint_load", "mean"),
        mean_wm_load=("wm_load", "mean"),
        mean_metacognition=("metacognitive_monitoring", "mean"),
        switch_rate=("switched_strategy", "mean"),
        mean_switch_count=("strategy_switch_count", "mean"),
        insight_rate=("insight_event", "mean"),
        accuracy_rate=("solution_accuracy", "mean"),
        mean_solution_quality=("solution_quality", "mean"),
        mean_errors=("error_count", "mean"),
        mean_confidence=("confidence", "mean"),
        mean_response_time_ms=("response_time_ms", "mean"),
    )
    .reset_index()
)

print(condition_summary)

# -----------------------------
# 2. Solution-accuracy model
# -----------------------------

accuracy_model = smf.glm(
    "solution_accuracy ~ condition + strategy_type + problem_difficulty "
    "+ representation_quality + goal_clarity + constraint_load + wm_load "
    "+ metacognitive_monitoring + switched_strategy + insight_event",
    data=df,
    family=sm.families.Binomial(),
)

accuracy_result = accuracy_model.fit(
    cov_type="cluster",
    cov_kwds={"groups": df["participant"]},
)

print(accuracy_result.summary())

# -----------------------------
# 3. Strategy-switch model
# -----------------------------

switch_model = smf.glm(
    "switched_strategy ~ condition + problem_difficulty + representation_quality "
    "+ constraint_load + wm_load + metacognitive_monitoring",
    data=df,
    family=sm.families.Binomial(),
)

switch_result = switch_model.fit(
    cov_type="cluster",
    cov_kwds={"groups": df["participant"]},
)

print(switch_result.summary())

# -----------------------------
# 4. Solution-quality model
# -----------------------------

quality_model = smf.ols(
    "solution_quality ~ condition + strategy_type + problem_difficulty "
    "+ representation_quality + goal_clarity + constraint_load + wm_load "
    "+ metacognitive_monitoring + insight_event + solution_accuracy + error_count",
    data=df,
)

quality_result = quality_model.fit(
    cov_type="cluster",
    cov_kwds={"groups": df["participant"]},
)

print(quality_result.summary())

# -----------------------------
# 5. Error-count model
# -----------------------------

error_model = smf.glm(
    "error_count ~ condition + strategy_type + problem_difficulty "
    "+ representation_quality + constraint_load + wm_load + metacognitive_monitoring",
    data=df,
    family=sm.families.Poisson(),
)

error_result = error_model.fit(
    cov_type="cluster",
    cov_kwds={"groups": df["participant"]},
)

print(error_result.summary())

# -----------------------------
# 6. Response-time model
# -----------------------------

rt_model = smf.ols(
    "log_response_time ~ condition + strategy_type + problem_difficulty "
    "+ representation_quality + constraint_load + wm_load "
    "+ strategy_switch_count + solution_accuracy",
    data=df,
)

rt_result = rt_model.fit(
    cov_type="cluster",
    cov_kwds={"groups": df["participant"]},
)

print(rt_result.summary())

# -----------------------------
# 7. Visualization
# -----------------------------

fig, ax = plt.subplots(figsize=(8, 5))

for strategy, group in df.groupby("strategy_type"):
    ax.scatter(
        group["representation_quality"],
        group["solution_quality"],
        alpha=0.35,
        label=str(strategy),
    )

ax.set_xlabel("Representation quality")
ax.set_ylabel("Solution quality")
ax.set_title("Problem representation and solution quality")
ax.legend(title="Strategy")
plt.tight_layout()
plt.show()

The Python workflow is intentionally transparent and extensible. It can be expanded with hierarchical Bayesian models, reinforcement-learning models of strategy selection, graph-based state-space search, process-tracing logs, eye-tracking features, verbal-protocol coding, computational models of means–end analysis, or human-AI problem-solving studies.

Back to top ↑

GitHub Repository

The companion repository provides reusable code and research scaffolding for studying problem solving in cognitive psychology, including workflows for strategy-use analysis, solution-accuracy modeling, solution-quality evaluation, working-memory-load effects, metacognitive monitoring, strategy-switching analysis, response-time modeling, error-count analysis, and computational simulations of state-space search.

Back to top ↑

Applications of problem-solving research

Problem-solving research matters across education, management, engineering, design, medicine, law, public policy, human-computer interaction, artificial intelligence, sustainability, and organizational learning. It helps explain how people structure tasks, why some representations support success while others obstruct it, and how strategy choice interacts with cognitive limits.

In education, problem-solving research helps instructors design learning environments that support representation, transfer, metacognition, and productive struggle. In medicine, it helps explain diagnostic reasoning, error, hypothesis testing, and the role of uncertainty. In engineering and design, it clarifies how teams decompose complex tasks, prototype solutions, and learn from failure. In public policy, it shows why systems problems cannot be solved by treating symptoms alone.

In organizations, problem-solving research is especially important because many failures are not caused by lack of effort. They are caused by poor framing, hidden assumptions, weak feedback, overloaded attention, misaligned incentives, inadequate tools, and rigid strategies. A team may be working hard while solving the wrong problem.

In human-computer interaction and AI, problem-solving research helps evaluate whether tools support representation and reasoning or simply generate outputs. A useful tool should reduce unnecessary cognitive burden while preserving enough visibility for humans to understand, challenge, and revise the solution process.

These applications matter because many real-world failures are not failures of motivation alone. They are failures of representation, coordination, feedback, or adaptation under complexity.

Back to top ↑

Conclusion

Problem solving is the process through which individuals represent goals, generate strategies, evaluate possibilities, monitor progress, and move toward solutions when answers are not immediately available. It depends on the coordination of memory, attention, working memory, reasoning, metacognition, strategy selection, feedback, and learning.

Cognitive psychology shows that effective problem solving depends not only on effort or intelligence, but on how problems are represented, how strategies are chosen, how working-memory demands are managed, and how flexibly cognition adapts when conditions are uncertain or changing.

Problem solving is therefore not merely a technical skill. It is a cognitive architecture for navigating complexity. It allows minds to construct problem spaces, search them, revise them, and learn from the consequences of action.

The central lesson is that solving a problem begins with understanding what kind of problem one is actually facing. When representation improves, strategy improves. When strategy improves, action becomes more intelligent. When feedback is taken seriously, problem solving becomes learning.

Back to top ↑

Related articles

• Cognitive Psychology
• Working Memory in Cognitive Psychology
• Attention in Cognitive Psychology
• Memory in Cognitive Psychology
• Mental Models in Cognitive Psychology
• Metacognition: Thinking About Thinking
• Analogical Reasoning and Knowledge Transfer
• Insight and Creative Problem Solving
• Decision Making in Cognitive Psychology

Further reading

• American Psychological Association (n.d.) APA Dictionary of Psychology. Available at: https://dictionary.apa.org/.
• Dörner, D. and Funke, J. (2017) ‘Complex problem solving: What it is and what it is not’, Frontiers in Psychology, 8, 1153. Available at: https://pmc.ncbi.nlm.nih.gov/articles/PMC5504467/.
• Keen, R. (2011) ‘The development of problem solving in young children: A critical cognitive skill’, Annual Review of Psychology, 62, pp. 1–21. Available at: https://pubmed.ncbi.nlm.nih.gov/20822435/.
• Newell, A. and Simon, H.A. (1972) Human Problem Solving. Englewood Cliffs, NJ: Prentice-Hall. Bibliographic record available at: https://books.google.com/books/about/Human_Problem_Solving.html?id=h03uAAAAMAAJ.
• Bartha, P. (2024) ‘Analogy and analogical reasoning’, Stanford Encyclopedia of Philosophy. Available at: https://plato.stanford.edu/entries/reasoning-analogy/.
• Kahneman, D. (2011) Thinking, Fast and Slow. New York: Farrar, Straus and Giroux.

Back to top ↑

References

• American Psychological Association (n.d.) APA Dictionary of Psychology. Available at: https://dictionary.apa.org/.
• Bartha, P. (2024) ‘Analogy and analogical reasoning’, Stanford Encyclopedia of Philosophy. Available at: https://plato.stanford.edu/entries/reasoning-analogy/.
• Dörner, D. and Funke, J. (2017) ‘Complex problem solving: What it is and what it is not’, Frontiers in Psychology, 8, 1153. Available at: https://pmc.ncbi.nlm.nih.gov/articles/PMC5504467/.
• Duncker, K. (1945) ‘On problem-solving’, Psychological Monographs, 58(5), i–113.
• Kahneman, D. (2011) Thinking, Fast and Slow. New York: Farrar, Straus and Giroux.
• Keen, R. (2011) ‘The development of problem solving in young children: A critical cognitive skill’, Annual Review of Psychology, 62, pp. 1–21. Available at: https://pubmed.ncbi.nlm.nih.gov/20822435/.
• Newell, A. and Simon, H.A. (1972) Human Problem Solving. Englewood Cliffs, NJ: Prentice-Hall. Bibliographic record available at: https://books.google.com/books/about/Human_Problem_Solving.html?id=h03uAAAAMAAJ.
• Polya, G. (1945) How to Solve It: A New Aspect of Mathematical Method. Princeton, NJ: Princeton University Press.

Back to top ↑