Mental Models in Cognitive Reasoning

By /

Last Updated May 20, 2026

Mental models are internal cognitive representations that individuals use to understand, interpret, simulate, and predict how systems, environments, relationships, tools, institutions, and processes operate. They allow the mind to simplify complex reality by organizing knowledge into structured frameworks that guide reasoning, decision making, learning, problem solving, and action. Rather than responding to the world as a stream of disconnected facts, people rely on internal models that capture relations, constraints, causes, feedback loops, possible interventions, and likely outcomes.

In cognitive psychology, mental models provide part of the conceptual architecture through which individuals make sense of complexity. People do not usually reason directly from raw data. They rely instead on structured internal representations that summarize causal relations, system behavior, constraints, affordances, risks, and expectations. These models make it possible to simulate what might happen, compare alternatives, anticipate consequences, and revise understanding without physically testing every possibility.

Mental models therefore play a central role in many processes explored elsewhere in this series, including decision making, heuristics, problem solving, cognitive learning, concept formation, metacognition, and cognitive load. A useful model can support prediction, insight, and adaptive action. A flawed model can produce persistent misunderstanding, overconfidence, policy failure, design breakdown, institutional blindness, and strategic error.


Main Library
Publications


Article Map
Cognitive Psychology


Related Topic
Behavioral Economics


Related Topic
Artificial Intelligence Systems


Related Topic
Data Systems & Analytics
Series context: This article is part of the Cognitive Psychology knowledge series, which examines attention, perception, memory, learning, reasoning, decision making, problem solving, language, human-computer interaction, artificial intelligence, and the cognitive architecture of human behavior.
Restrained institutional illustration showing cognitive reasoning through mental models, with information filtered into internal structures, symbolic maps, causal chains, decision paths, uncertainty, evaluation, and outcomes.
Mental models support cognitive reasoning by organizing information into internal structures that help people interpret evidence, simulate possibilities, evaluate alternatives, and choose actions.

The concept matters because human reasoning is almost always model-mediated. A person trying to understand a machine, a classroom, a disease, a market, a climate system, a legal process, a software interface, or an organization must simplify. The question is not whether the mind uses simplified representations. It is whether those representations preserve the relations that matter most.

The concept of mental models

A mental model is an internal representation of how something works. It may represent a physical system, a social relationship, a technical tool, an institutional process, an economic mechanism, a biological pathway, a policy environment, a moral situation, or a future possibility. Mental models are not merely collections of facts. They are structured representations of relations.

The idea is especially associated with Philip Johnson-Laird, who argued that reasoning often depends on constructing internal representations that preserve the structure of the situations under consideration. Instead of manipulating abstract rules alone, the mind can represent possible states of affairs, inspect them, and draw conclusions from the structure of the model itself.

This is one reason mental models are so useful as a cognitive concept. They help explain how people can reason about systems they cannot directly observe in full. A person may form a model of a machine, a workplace, a policy process, a market, a disease, a digital interface, a legal system, or an ecological environment, and then use that model to anticipate what might happen under different conditions.

Mental models help people answer questions such as:

  • What elements belong to the system?
  • How are those elements connected?
  • What causes what?
  • What constraints limit possible outcomes?
  • What feedback loops amplify or stabilize change?
  • What will happen if one variable changes?
  • Where are the boundaries of the system?
  • What is missing from my representation?

In this sense, mental models function as cognitive tools for understanding complexity rather than as mere repositories of information. They give thought a structure to work with.

But mental models are always partial. They are simplified, selective, and often unstable. A model may be useful without being fully accurate. It may support everyday action while still failing under unusual conditions. This makes mental models powerful and risky at the same time.

Back to top ↑

Historical foundations: cognitive maps, small-scale models, and representation

The intellectual history of mental models is broader than any single theory. Edward Tolman’s work on cognitive maps helped establish the idea that behavior can depend on internal representations of spatial and relational structure, not only on immediate stimulus-response chains. His 1948 paper on cognitive maps in rats and humans became a foundational source for later representational theories of cognition.

Kenneth Craik’s The Nature of Explanation also anticipated later cognitive-science thinking by treating thought as involving internal models that can parallel or simulate external events. In this view, the mind can construct small-scale representations of reality, manipulate them internally, and use them to anticipate what might happen.

Johnson-Laird’s later theory of mental models gave the concept a more precise role in reasoning. Mental models became a way of explaining how people draw conclusions, understand possibilities, and reason about relations without relying only on formal logical rules. This line of research remains central to contemporary theories of reasoning.

Gentner and Stevens’s edited volume Mental Models helped consolidate the field by gathering work across cognition, knowledge representation, science learning, intuitive physics, human-computer interaction, and domain understanding. The volume made clear that mental models were not only a theory of reasoning, but also a general research program for studying how people represent the world.

In human-computer interaction and design, Donald Norman emphasized the distinction between a user’s mental model, a designer’s conceptual model, and the system image presented through the interface. This became especially important because users often act according to what they believe a system does, not according to the technical structure the designer intended.

Across these traditions, one shared idea remains: cognition is mediated by internal representations that make the world intelligible enough to reason about, act on, and revise.

Back to top ↑

How mental models support reasoning

Reasoning often requires imagining how events might unfold under different conditions. Mental models support this process by allowing individuals to simulate possibilities internally rather than relying entirely on trial and error in the external world.

When people solve a problem, plan a strategy, interpret a system, or evaluate an argument, they often construct simplified internal representations of the situation. Those representations allow them to test possible outcomes, anticipate obstacles, and compare alternatives before acting. This is one reason mental models are closely tied to decision making, heuristics, and problem solving: they provide the internal structure through which uncertain situations become manageable enough to think about.

Mental models support reasoning by making several operations possible:

  • Simulation — imagining how a system may change over time.
  • Prediction — estimating likely outcomes from current conditions.
  • Counterfactual reasoning — asking what would happen if something were different.
  • Causal explanation — identifying why an outcome occurred.
  • Intervention planning — choosing where to act in a system.
  • Constraint recognition — identifying what cannot happen or what is unlikely.
  • Transfer — applying a model from one situation to a structurally similar one.

Because mental models simplify reality, they are both powerful and imperfect. Their value lies in making complex systems tractable. Their danger lies in the fact that simplification may omit a crucial relation, misrepresent a feedback loop, treat a dynamic system as static, or assume linear effects where nonlinear change is more accurate.

A good mental model does not reproduce the full world. It preserves enough structure to support useful reasoning. A poor mental model preserves the wrong structure and therefore makes error feel reasonable.

Back to top ↑

Formalizing mental models: representation, simulation, and prediction

Mental models can be described formally as structured representations of entities, relations, boundaries, and transition rules. Let a model \(M\) be represented as:

\[
M = (E, R, T, B)
\]

Interpretation: A mental model \(M\) consists of entities \(E\), relations \(R\), transition rules \(T\), and boundary assumptions \(B\). This makes explicit that a model is not merely a list of facts, but a structured representation of how a system is believed to work.

If a current state of the system is \(s_t\), then a simple predictive use of a mental model can be represented as:

\[
\hat{s}_{t+1}=f(M,s_t,a_t)
\]

Interpretation: The model is used to predict a future state \(\hat{s}_{t+1}\) from the current state \(s_t\), the internal model \(M\), and a possible action or intervention \(a_t\).

Model quality can also be expressed as the degree of fit between predicted and observed states:

\[
\epsilon = \|s_{t+1}-\hat{s}_{t+1}\|
\]

Interpretation: Prediction error \(\epsilon\) measures the gap between what actually happens and what the model predicted would happen. Large error may indicate that the mental model needs revision.

At a more general level, one can think of mental models as compressed representations:

\[
M \approx g(X)
\]

Interpretation: A mental model \(M\) approximates the full complexity of the world \(X\) through a simplifying transformation \(g\). The model is useful because it compresses complexity, but every compression leaves something out.

Model revision can be represented as an update after feedback:

\[
M_{t+1}=M_t+\alpha\,h(\epsilon_t,F_t)
\]

Interpretation: A mental model is revised when prediction error \(\epsilon_t\) and feedback \(F_t\) provide enough information to change the model, with \(\alpha\) representing the learner’s sensitivity to revision.

Transfer can be represented as a relation between model quality and structural similarity:

\[
T_{A\to B} \propto Q(M_A)\cdot S(A,B)
\]

Interpretation: Transfer from context \(A\) to context \(B\) depends on the quality of the model learned in \(A\) and the structural similarity between the two contexts.

These formalizations are simplified, but useful. They show why mental-model research can be empirical. Researchers can measure prediction error, intervention accuracy, model completeness, causal-link accuracy, model revision, transfer, confidence, and reasoning time.

Back to top ↑

Mental models and system understanding

Mental models are especially important when individuals interact with complex systems. Economic markets, technological infrastructures, ecological systems, bureaucratic institutions, health systems, legal processes, climate systems, and organizational environments all contain interacting components whose behavior cannot be understood through isolated observations alone.

To navigate such environments, individuals construct internal representations that capture what they take to be the structure of the system. These representations may include assumptions about:

  • causal relationships between variables;
  • feedback processes within the system;
  • delays between action and outcome;
  • constraints, thresholds, and limits;
  • roles, incentives, and institutional rules;
  • probable outcomes of specific actions;
  • unintended consequences;
  • which actors or variables are inside or outside the relevant boundary.

When these assumptions align reasonably well with the underlying structure of the system, mental models allow individuals to make useful predictions. When they do not, misunderstanding, poor judgment, strategic failure, and institutional error often follow.

Complex systems are especially difficult because they involve feedback, delay, nonlinear behavior, indirect effects, and hidden dependencies. John Sterman’s systems work emphasizes that learning in complex systems requires making assumptions visible, testing them against feedback, and revising the models that guide decisions. This is precisely where mental models become both cognitively and institutionally important.

Many problems that look like failures of decision making are more fundamentally failures of model quality. A person cannot choose wisely if the model behind the choice omits the most important causal relations.

Back to top ↑

Mental models and cognitive bias

Mental models also play an important role in cognitive bias. Because people interpret new information through the lens of existing internal representations, they often notice evidence that fits their models more readily than evidence that conflicts with them.

This can contribute to confirmation bias, overconfidence, motivated reasoning, framing effects, availability effects, and interpretive rigidity. Once a person has formed a strong model of how a system works, that model can shape attention, memory retrieval, explanation, and expectation in self-reinforcing ways.

Inaccurate models can therefore persist not because they are constantly confirmed by reality, but because they influence:

  • which evidence is noticed;
  • which anomalies are dismissed;
  • which causes are considered plausible;
  • which alternatives are treated as realistic;
  • which outcomes are interpreted as success or failure;
  • which feedback is trusted;
  • which voices are treated as credible.

This is one reason mental models are both enabling and constraining. They support efficient reasoning, but they can also narrow the range of alternatives a person is prepared to see. A flawed model can make error feel like common sense.

Metacognition helps here. A person can ask: What model am I using? What would count as evidence against it? What assumptions does it depend on? What variables are missing? Who sees the system differently, and why?

A mature cognitive approach to mental models therefore requires more than building models. It requires learning how to examine, test, and revise them.

Back to top ↑

Mental models in learning and expertise

Learning often involves refining and expanding mental models. As individuals gain knowledge within a domain, they begin to represent deeper relations, broader contexts, and more accurate causal structures. What novices often treat as disconnected details, experts more often see as parts of a larger organized system.

This connects mental models directly to cognitive learning. Learning is not only the acquisition of new information. It is the transformation of internal structure. A learner who memorizes facts without changing the model may fail to understand the system. A learner who revises the model can often apply knowledge flexibly in new contexts.

Research on expertise suggests that experts frequently possess richer and more accurate models than novices. These models allow them to recognize patterns more quickly, anticipate system behavior more effectively, and identify solutions that are not immediately obvious from the surface features of a problem.

Mental models also connect to memory and working memory. Structured knowledge stored in long-term memory can reduce the burden on real-time processing and make complex reasoning more efficient. A strong model reduces the number of isolated facts that must be held at once because it organizes them into meaningful relations.

This is why good instruction often focuses on models, not just information. Students need to know not only what is true, but how parts of a system fit together and what changes when one part is altered.

Back to top ↑

Mental models and problem solving

Many problem-solving strategies depend on the ability to construct and manipulate mental models. When individuals encounter unfamiliar problems, they often attempt to build an internal representation that captures the structure of the situation. That representation then serves as the basis for simulation, comparison, prediction, and intervention.

Engineers, scientists, clinicians, policy analysts, designers, managers, teachers, and community organizers all rely on conceptual models in this sense. They imagine how variables interact, what interventions are likely to matter, where failure may occur, and where unintended consequences may arise. These internal simulations allow them to explore alternative scenarios before acting in the real system itself.

Problem solving through mental models often includes:

  • identifying the relevant elements of the problem;
  • mapping causal relations;
  • recognizing constraints;
  • testing possible interventions internally;
  • anticipating feedback and delay;
  • comparing alternative explanations;
  • revising the model when predictions fail.

A major source of problem-solving failure is poor problem representation. If the initial model is wrong, even skilled reasoning can move efficiently in the wrong direction. This is why reframing is often a critical part of problem solving. The question is not only how to solve the problem, but whether the problem has been modeled correctly.

In this sense, mental models provide a bridge between abstract thought and practical action. They are how people reason about systems before intervening in them.

Back to top ↑

Mental models in design, HCI, and human factors

Mental models are central to design and human-computer interaction because users act according to what they believe a system does. A system may be technically well engineered but still difficult to use if its interface does not support an accurate user model.

Donald Norman’s design work emphasized the distinction between the designer’s model, the user’s mental model, and the system image. The designer may understand the underlying architecture, but the user encounters only the visible controls, labels, feedback, affordances, constraints, and outcomes. If the system image does not communicate the right structure, users may build incorrect models and make predictable errors.

In HCI, mental-model failures can appear when users:

  • misunderstand what a button or control does;
  • expect one causal relation but encounter another;
  • cannot infer system state from feedback;
  • do not know whether an action succeeded;
  • apply a model from an older system to a new one;
  • misunderstand automation, AI assistance, or hidden constraints;
  • cannot recover from error because the system model is unclear.

Good design helps users form usable, accurate, and recoverable models. This does not require exposing every technical detail. It requires making the relevant system logic visible enough for users to act intelligently.

This is especially important in high-stakes systems: medical devices, financial tools, public-benefit portals, transportation interfaces, emergency systems, infrastructure dashboards, AI decision-support tools, and legal or administrative platforms. A poor interface can create a poor mental model, and a poor mental model can produce harm.

Back to top ↑

Mental models, institutions, and power

Mental models are not only individual. Institutions also operate through shared models of how the world works. A school has a model of learning. A hospital has a model of diagnosis and care. A company has a model of markets and customers. A court has a model of evidence and responsibility. A government agency has a model of eligibility, risk, compliance, and public need.

These institutional models matter because they shape what is measured, funded, ignored, rewarded, punished, or treated as legitimate. A flawed institutional model can make structural causes look like individual failures. It can make marginalized experience invisible. It can treat symptoms as causes, proxies as truth, or administrative convenience as fairness.

Institutional mental models shape:

  • which problems are recognized;
  • which forms of evidence count;
  • which populations are treated as central or peripheral;
  • which causal stories are considered plausible;
  • which solutions are considered realistic;
  • which harms are treated as accidental, inevitable, or invisible.

This is where mental models connect to justice and accountability. A model is never only a private cognitive tool when it guides institutional action. If a model decides who receives care, protection, funding, attention, or credibility, then its assumptions must be open to scrutiny.

For marginalized communities, the problem is often not lack of experience but lack of institutional recognition. Communities may understand system failure through lived causal knowledge long before institutions update their models. A serious account of mental models should therefore ask not only how individuals represent systems, but whose models are allowed to shape collective decisions.

Back to top ↑

Mental models and artificial intelligence systems

Artificial intelligence makes mental models newly urgent. Users form models of what AI systems know, how reliable they are, how they produce answers, what evidence they use, what uncertainty remains, and when outputs should be trusted. These user models often differ sharply from the system’s actual capabilities and limits.

AI systems can support better mental models when they make sources, uncertainty, assumptions, reasoning limits, data boundaries, and failure modes visible. They can damage mental models when they produce fluent answers without provenance, hide uncertainty, imitate authority, or make probabilistic output feel like verified knowledge.

Human-AI interaction therefore depends on calibrated model formation. Users need to understand enough about the system to ask:

  • What kind of task is this system good at?
  • What evidence supports this output?
  • What is uncertain?
  • What does the system not know?
  • Am I relying on fluency instead of verification?
  • Where could hidden assumptions or training data limitations matter?
  • What would I need to check before acting?

AI systems also create new research opportunities. Cognitive psychologists can study how people build mental models of intelligent tools, when they over-trust or under-trust them, how explanations change model quality, and whether AI support improves or weakens human reasoning over time.

The deeper issue is not whether AI can produce outputs. It is whether human users can build accurate enough mental models of AI systems to use them responsibly.

Back to top ↑

Mental models in contemporary cognitive science

Modern research on mental models draws from cognitive psychology, philosophy of mind, systems theory, neuroscience, human factors, education, artificial intelligence, and human-computer interaction. Philosophical work on mental representation provides a broader background for understanding how internal states can stand for, encode, or carry information about structure in the world.

Within psychology, mental-model research remains especially important in reasoning. Johnson-Laird’s work continues to shape how psychologists think about deduction, possibility, counterfactual reasoning, and simulation. His PNAS article on mental models and human reasoning remains one of the clearest concise statements of the theory’s role in explaining inference.

In human factors and systems research, Rouse and Morris’s work remains important because it treats mental models functionally: people use them to generate descriptions of system purpose and form, explanations of system behavior, and predictions of future system states. This makes mental models central to system operation, design, training, and safety.

In systems thinking, Sterman’s work emphasizes that learning in complex systems requires surfacing and revising the mental models that guide action. This is especially important when feedback is delayed, incomplete, politicized, or hard to interpret.

In education and expertise research, mental models help explain why learners sometimes retain facts without understanding systems. A learner may know components but not relations, terms but not mechanisms, examples but not structure. Strong learning often requires building a better model, not merely remembering more details.

Across these fields, one point remains stable: mental models are indispensable because human beings must reason under partial information. The question is whether the models we use are accurate enough, flexible enough, and accountable enough for the systems we are trying to understand.

Back to top ↑

R code for mental-model data

The following R workflow illustrates analyses relevant to mental-model research, including model completeness, model coherence, causal-link accuracy, feedback-loop recognition, boundary accuracy, prediction error, problem-solving success, model revision, transfer, reasoning time, cognitive load, and explanation quality.

# 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, domain, trial, scenario_id,
# model_completeness, model_coherence, causal_link_accuracy,
# feedback_loop_recognition, boundary_accuracy, structural_similarity,
# prediction_error, system_understanding_score, problem_success,
# intervention_choice_accuracy, model_revision_score, transfer_score,
# reasoning_time_ms, confidence, cognitive_load, explanation_quality

dat <- read_csv("mental_models_trials.csv") %>%
  mutate(
    participant = factor(participant),
    condition = factor(condition),
    domain = factor(domain),
    scenario_id = factor(scenario_id),
    problem_success = as.integer(problem_success),
    intervention_choice_accuracy = as.integer(intervention_choice_accuracy),
    log_reasoning_time = log(reasoning_time_ms)
  )

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

condition_summary <- dat %>%
  group_by(condition) %>%
  summarise(
    n_trials = n(),
    participants = n_distinct(participant),
    mean_completeness = mean(model_completeness, na.rm = TRUE),
    mean_coherence = mean(model_coherence, na.rm = TRUE),
    mean_causal_accuracy = mean(causal_link_accuracy, na.rm = TRUE),
    mean_feedback_loop_recognition = mean(feedback_loop_recognition, na.rm = TRUE),
    mean_boundary_accuracy = mean(boundary_accuracy, na.rm = TRUE),
    mean_prediction_error = mean(prediction_error, na.rm = TRUE),
    mean_system_understanding = mean(system_understanding_score, na.rm = TRUE),
    success_rate = mean(problem_success, na.rm = TRUE),
    intervention_accuracy = mean(intervention_choice_accuracy, na.rm = TRUE),
    mean_revision = mean(model_revision_score, na.rm = TRUE),
    mean_transfer = mean(transfer_score, na.rm = TRUE),
    mean_cognitive_load = mean(cognitive_load, na.rm = TRUE),
    mean_explanation_quality = mean(explanation_quality, na.rm = TRUE),
    .groups = "drop"
  )

print(condition_summary)

# -----------------------------
# 2. Prediction-error model
# -----------------------------

prediction_error_model <- lmer(
  prediction_error ~
    condition +
    domain +
    model_completeness +
    model_coherence +
    causal_link_accuracy +
    feedback_loop_recognition +
    boundary_accuracy +
    structural_similarity +
    cognitive_load +
    (1 | participant) +
    (1 | scenario_id),
  data = dat,
  REML = FALSE
)

summary(prediction_error_model)
emmeans(prediction_error_model, ~ condition)

# -----------------------------
# 3. System-understanding model
# -----------------------------

understanding_model <- lmer(
  system_understanding_score ~
    condition +
    domain +
    model_completeness +
    model_coherence +
    causal_link_accuracy +
    feedback_loop_recognition +
    boundary_accuracy +
    cognitive_load +
    (1 | participant) +
    (1 | scenario_id),
  data = dat,
  REML = FALSE
)

summary(understanding_model)

# -----------------------------
# 4. Problem-success model
# -----------------------------

success_model <- glmer(
  problem_success ~
    condition +
    domain +
    system_understanding_score +
    prediction_error +
    causal_link_accuracy +
    feedback_loop_recognition +
    boundary_accuracy +
    confidence +
    (1 | participant) +
    (1 | scenario_id),
  data = dat,
  family = binomial(),
  control = glmerControl(optimizer = "bobyqa")
)

summary(success_model)
emmeans(success_model, ~ condition, type = "response")

# -----------------------------
# 5. Intervention-choice model
# -----------------------------

intervention_model <- glmer(
  intervention_choice_accuracy ~
    condition +
    domain +
    causal_link_accuracy +
    feedback_loop_recognition +
    boundary_accuracy +
    system_understanding_score +
    prediction_error +
    (1 | participant) +
    (1 | scenario_id),
  data = dat,
  family = binomial(),
  control = glmerControl(optimizer = "bobyqa")
)

summary(intervention_model)

# -----------------------------
# 6. Model-revision model
# -----------------------------

revision_model <- lmer(
  model_revision_score ~
    condition +
    domain +
    prediction_error +
    feedback_loop_recognition +
    causal_link_accuracy +
    model_coherence +
    cognitive_load +
    (1 | participant) +
    (1 | scenario_id),
  data = dat,
  REML = FALSE
)

summary(revision_model)

# -----------------------------
# 7. Transfer model
# -----------------------------

transfer_model <- lmer(
  transfer_score ~
    condition +
    domain +
    structural_similarity +
    model_coherence +
    causal_link_accuracy +
    boundary_accuracy +
    system_understanding_score +
    problem_success +
    (1 | participant) +
    (1 | scenario_id),
  data = dat,
  REML = FALSE
)

summary(transfer_model)

# -----------------------------
# 8. Reasoning-time model
# -----------------------------

reasoning_time_model <- lmer(
  log_reasoning_time ~
    condition +
    domain +
    model_coherence +
    cognitive_load +
    prediction_error +
    system_understanding_score +
    problem_success +
    (1 | participant) +
    (1 | scenario_id),
  data = dat,
  REML = FALSE
)

summary(reasoning_time_model)

# -----------------------------
# 9. Visualization
# -----------------------------

ggplot(dat, aes(x = system_understanding_score, y = prediction_error, color = condition)) +
  geom_point(alpha = 0.25) +
  geom_smooth(method = "lm", se = FALSE) +
  labs(
    title = "System understanding and prediction error",
    x = "System understanding score",
    y = "Prediction error"
  ) +
  theme_minimal()

This workflow can be adapted for mental-model elicitation studies, causal-diagram coding, HCI experiments, systems-thinking instruction, complex-domain learning, expert-novice comparison, decision-support evaluation, AI-assisted reasoning studies, and organizational-learning research. Researchers should model participant and scenario effects whenever possible because model quality varies strongly across people, domains, tasks, interfaces, and system complexity.

Back to top ↑

Python code for mental-model data

The Python examples below parallel the R workflow and are useful for reasoning experiments, system-understanding studies, model-quality comparisons, HCI research, transfer studies, and model-revision analysis.

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, domain, trial, scenario_id,
# model_completeness, model_coherence, causal_link_accuracy,
# feedback_loop_recognition, boundary_accuracy, structural_similarity,
# prediction_error, system_understanding_score, problem_success,
# intervention_choice_accuracy, model_revision_score, transfer_score,
# reasoning_time_ms, confidence, cognitive_load, explanation_quality

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

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

df["problem_success"] = df["problem_success"].astype(int)
df["intervention_choice_accuracy"] = df["intervention_choice_accuracy"].astype(int)
df["log_reasoning_time"] = np.log(df["reasoning_time_ms"])

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

condition_summary = (
    df.groupby("condition", observed=True)
    .agg(
        n_trials=("problem_success", "size"),
        participants=("participant", "nunique"),
        mean_completeness=("model_completeness", "mean"),
        mean_coherence=("model_coherence", "mean"),
        mean_causal_accuracy=("causal_link_accuracy", "mean"),
        mean_feedback_loop_recognition=("feedback_loop_recognition", "mean"),
        mean_boundary_accuracy=("boundary_accuracy", "mean"),
        mean_prediction_error=("prediction_error", "mean"),
        mean_system_understanding=("system_understanding_score", "mean"),
        success_rate=("problem_success", "mean"),
        intervention_accuracy=("intervention_choice_accuracy", "mean"),
        mean_revision=("model_revision_score", "mean"),
        mean_transfer=("transfer_score", "mean"),
        mean_cognitive_load=("cognitive_load", "mean"),
        mean_explanation_quality=("explanation_quality", "mean"),
    )
    .reset_index()
)

print(condition_summary)

# -----------------------------
# 2. Prediction-error model
# -----------------------------

prediction_error_model = smf.ols(
    "prediction_error ~ condition + domain + model_completeness "
    "+ model_coherence + causal_link_accuracy + feedback_loop_recognition "
    "+ boundary_accuracy + structural_similarity + cognitive_load",
    data=df,
)

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

print(prediction_error_result.summary())

# -----------------------------
# 3. System-understanding model
# -----------------------------

understanding_model = smf.ols(
    "system_understanding_score ~ condition + domain + model_completeness "
    "+ model_coherence + causal_link_accuracy + feedback_loop_recognition "
    "+ boundary_accuracy + cognitive_load",
    data=df,
)

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

print(understanding_result.summary())

# -----------------------------
# 4. Problem-success model
# -----------------------------

success_model = smf.glm(
    "problem_success ~ condition + domain + system_understanding_score "
    "+ prediction_error + causal_link_accuracy + feedback_loop_recognition "
    "+ boundary_accuracy + confidence",
    data=df,
    family=sm.families.Binomial(),
)

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

print(success_result.summary())

# -----------------------------
# 5. Intervention-choice model
# -----------------------------

intervention_model = smf.glm(
    "intervention_choice_accuracy ~ condition + domain + causal_link_accuracy "
    "+ feedback_loop_recognition + boundary_accuracy + system_understanding_score "
    "+ prediction_error",
    data=df,
    family=sm.families.Binomial(),
)

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

print(intervention_result.summary())

# -----------------------------
# 6. Model-revision model
# -----------------------------

revision_model = smf.ols(
    "model_revision_score ~ condition + domain + prediction_error "
    "+ feedback_loop_recognition + causal_link_accuracy + model_coherence "
    "+ cognitive_load",
    data=df,
)

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

print(revision_result.summary())

# -----------------------------
# 7. Transfer model
# -----------------------------

transfer_model = smf.ols(
    "transfer_score ~ condition + domain + structural_similarity "
    "+ model_coherence + causal_link_accuracy + boundary_accuracy "
    "+ system_understanding_score + problem_success",
    data=df,
)

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

print(transfer_result.summary())

# -----------------------------
# 8. Reasoning-time model
# -----------------------------

reasoning_time_model = smf.ols(
    "log_reasoning_time ~ condition + domain + model_coherence "
    "+ cognitive_load + prediction_error + system_understanding_score "
    "+ problem_success",
    data=df,
)

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

print(reasoning_time_result.summary())

# -----------------------------
# 9. Visualization
# -----------------------------

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

for condition, group in df.groupby("condition", observed=True):
    ax.scatter(
        group["system_understanding_score"],
        group["prediction_error"],
        alpha=0.35,
        label=str(condition),
    )

ax.set_xlabel("System understanding score")
ax.set_ylabel("Prediction error")
ax.set_title("System understanding and prediction error")
ax.legend(title="Condition")
plt.tight_layout()
plt.show()

The Python workflow is intentionally transparent and extensible. It can be expanded with Bayesian mental-model comparison, causal-graph scoring, structural-equation modeling, network analysis, latent-class models, HCI task logs, dynamic-systems simulations, transfer-detection models, human-AI reliance measures, and dashboards for comparing confidence against prediction accuracy.

Back to top ↑

GitHub Repository

The companion repository provides reusable code and research scaffolding for studying mental models in cognitive psychology, including workflows for model completeness, model coherence, causal-link accuracy, feedback-loop recognition, boundary accuracy, prediction error, system understanding, problem-solving success, intervention choice, model revision, transfer, cognitive load, explanation quality, and reasoning time.

Complete Code Repository

Access the full companion repository for this article, including reproducible analysis materials and multi-language code workflows for mental-model research.

View the Full GitHub Repository

Back to top ↑

Applications of mental-model research

Mental models are important across education, design, technology, medicine, law, public policy, sustainability, organizational strategy, artificial intelligence, risk communication, and systems governance. They help explain why people understand some systems quickly, misunderstand others persistently, and sometimes continue to act on models that no longer match reality.

In education, mental models help explain why deep understanding depends on more than fact acquisition. Learners need to build structured representations of how concepts relate, how mechanisms work, and how principles transfer across cases.

In design and HCI, mental models clarify why users struggle when interfaces do not match their expectations of how a system works. Good design supports accurate user models through visible structure, feedback, constraints, affordances, and recoverable action.

In medicine and public health, mental models shape how patients understand risk, treatment, causality, symptoms, prevention, and uncertainty. They also shape how professionals reason through diagnostic and institutional systems.

In policy and governance, mental models influence how decision makers define problems, identify causes, choose interventions, and interpret feedback. A policy based on a weak model may fail even when implemented efficiently.

In artificial intelligence, mental models are essential for calibrated use. Users must understand what systems can do, what they cannot do, what uncertainty remains, and what verification is required before acting.

These applications matter because mental models sit at the boundary between knowledge and action. They are part of what allows people to project themselves beyond immediate data and reason about systems that are only partially visible.

Back to top ↑

Conclusion

Mental models are internal representations through which individuals simplify, interpret, simulate, and predict the structure of complex systems. They allow the mind to move beyond isolated facts and reason about relations, constraints, causes, feedback loops, and possible outcomes.

Cognitive psychology shows that these models are indispensable for reasoning, decision making, learning, design, expertise, and problem solving. But mental models are always partial. They make complexity manageable, yet they can also mislead when their structure is incomplete, inaccurate, rigid, or shaped by unequal power.

The central lesson is that human cognition does not only depend on information. It depends on the models through which information is organized. Better thinking often requires better models: models that are more accurate, more flexible, more open to feedback, and more accountable to the systems and people they affect.

Back to top ↑

Further reading

Back to top ↑

References

Back to top ↑

Scroll to Top