Mental Models and the Limits of Linear Reasoning

Last Updated June 1, 2026

Mental models are the internal maps people use to interpret reality. They shape what we notice, what we ignore, what we call a problem, what we consider evidence, what solutions feel reasonable, and what futures seem possible. In systems thinking, mental models matter because complex systems rarely behave according to simple, linear expectations. When people assume that one cause produces one effect, that more effort always produces more improvement, that feedback is immediate, or that a problem can be solved by fixing one part, they often misread the system they are trying to change.

Linear reasoning is useful in simple situations. If a machine part breaks, replacing the part may solve the problem. If a document has an error, correcting the error may be enough. If a clear rule is missing, adding the rule may help. But many social, ecological, technological, organizational, and institutional systems do not behave this way. They involve feedback loops, delays, adaptation, threshold effects, unintended consequences, competing goals, shifting incentives, hidden stocks, and relationships that change over time. In those systems, linear reasoning can produce confident mistakes.

This article examines mental models and the limits of linear reasoning in systems thinking. It explains why people default to simple cause-effect explanations, how those explanations fail in complex systems, and how mental models can either reveal or hide feedback loops, delays, incentives, stocks, flows, adaptation, and power. It also explores the ethical stakes of mental models: who gets to define the problem, whose experience is treated as evidence, who is blamed when systems fail, and how better reasoning can support more just and durable system redesign.

Why Mental Models Matter

Mental models matter because people do not respond directly to reality. They respond to their interpretation of reality. A leader sees low productivity and assumes people need more pressure. A policymaker sees low participation and assumes people need more information. A school sees poor scores and assumes teachers need tighter accountability. A platform sees engagement and assumes users value what the algorithm amplifies. A public agency sees application errors and assumes applicants are careless. Each interpretation leads to action. If the mental model is wrong, the action may intensify the problem.

Systems thinking begins by recognizing that many failures are failures of interpretation before they are failures of execution. If the system is misread, even a well-executed intervention can fail. More pressure can deepen burnout. More information can worsen distrust if access and legitimacy are the real constraints. More enforcement can increase avoidance. More road capacity can induce more traffic. More metrics can create gaming. More technology can scale a flawed process.

Mental models are especially important because they often feel like common sense. People rarely experience their assumptions as assumptions. They experience them as reality. A linear mental model may say: if output is low, increase effort; if people do not comply, increase enforcement; if public trust is low, improve messaging; if a process is slow, automate it; if a metric is weak, attach incentives to it. Each of these can sometimes help. But each can also fail if the real problem is systemic.

Mental models also matter because they distribute responsibility. A mental model that locates failure inside individuals will produce blame, training, discipline, or motivation campaigns. A mental model that locates failure inside structure will examine rules, incentives, feedback, capacity, information, authority, and goals. The difference is not academic. It changes who is held responsible, what gets redesigned, and who carries the burden when the system continues to fail.

Back to top ↑

What Mental Models Are

A mental model is a simplified representation of how something works. It may be explicit, like a diagram, theory, strategy, or operating principle. It may also be implicit, embedded in habit, language, culture, professional training, institutional routine, or personal experience. Mental models help people act in a complex world by reducing complexity. Without them, decision-making would be impossible. The problem is not that people use mental models. The problem is that people often use incomplete models without recognizing their limits.

Mental models shape attention. They tell us what counts as signal and what counts as noise. A financial model may notice cost but miss burden. A compliance model may notice rule violations but miss administrative complexity. A marketing model may notice audience response but miss trust. An engineering model may notice technical performance but miss social adoption. A policy model may notice eligibility rules but miss how people experience them.

Mental models also shape causality. They define what causes what. If a leader believes that performance is mainly caused by effort, the leader will emphasize motivation and discipline. If the leader believes performance is caused by system design, the leader will examine workload, tools, incentives, feedback, capacity, and coordination. The same evidence can be interpreted differently depending on the model.

Mental models can be individual, organizational, professional, cultural, disciplinary, or institutional. A physician, engineer, lawyer, economist, teacher, planner, software developer, manager, activist, and community member may each bring different models to the same problem. Those models may reveal different truths. Systems thinking does not ask people to abandon expertise. It asks them to recognize that every model is partial.

Useful mental models have several qualities:

• they make assumptions visible;
• they can be revised when evidence changes;
• they include feedback and delay where relevant;
• they distinguish symptoms from structure;
• they recognize uncertainty;
• they include multiple perspectives;
• they show what is outside the model boundary;
• they help people learn, not only defend a position.

A mental model becomes dangerous when it is treated as reality itself. Models are maps. A map can guide action, but it can also omit terrain, erase people, simplify history, hide power, and create false confidence. Systems thinking uses models while remaining aware that models need critique, revision, and humility.

Back to top ↑

What Linear Reasoning Assumes

Linear reasoning assumes that causes and effects are direct, proportional, and relatively predictable. It imagines change as a sequence: A causes B, B causes C, and intervention at A should produce a corresponding change in C. This reasoning is useful for many practical tasks. If a light bulb burns out, replacing it usually restores light. If a file is missing, uploading it may solve the issue. If a simple process lacks a step, adding the step may improve reliability.

Linear reasoning becomes problematic when applied to systems that are adaptive, delayed, nonlinear, and feedback-rich. In those systems, causes can circle back on themselves. Effects can become causes. Short-term improvement can create long-term harm. Small changes can produce large effects under some conditions and no effect under others. Interventions can trigger compensation. People can adapt to rules. Stocks can accumulate invisibly until thresholds are crossed.

Linear reasoning often assumes:

• one main cause produces one main effect;
• more input produces more output;
• effects appear soon after causes;
• the system will not adapt to the intervention;
• fixing a part fixes the whole;
• the observed symptom is the real problem;
• feedback is weak or irrelevant;
• past relationships will remain stable;
• people respond as policy designers expect;
• side effects are secondary rather than central.

A systems view expands the model:

Linear reasoning is attractive because it feels clear. It simplifies responsibility, speeds decision-making, and supports confident action. It can also serve institutional power by locating problems in visible actors rather than hidden structures. If the problem is “people are not trying,” leaders can demand effort. If the problem is “the system creates conditions where effort is depleted, misdirected, or unrewarded,” the organization must examine itself.

The limit of linear reasoning is not that it is always wrong. It is that it often stops too soon. Systems thinking asks what happens after the first effect, how the system responds, what accumulates, what is delayed, who adapts, and whether the intervention changes the structure or merely presses on a symptom.

Back to top ↑

Why Linear Reasoning Fails in Complex Systems

Linear reasoning fails in complex systems because complex systems are organized by relationships, not isolated parts. Their behavior emerges from interaction. A change in one place can alter incentives elsewhere. A short-term fix can reduce pressure while weakening long-term capacity. A rule can change the behavior it was designed to measure. An intervention can create side effects that become more important than the original effect.

One major limit is proportionality. In simple linear thinking, twice the input should produce roughly twice the output. In complex systems, response may be nonlinear. A small trust violation can cause a large legitimacy crisis if trust is already fragile. A modest workload increase can trigger burnout if capacity is already depleted. A small temperature change can alter ecological dynamics if thresholds are near. A small policy change can produce large avoidance behavior if people are already burdened.

Another limit is delay. Linear reasoning often expects quick feedback. Complex systems may respond slowly. Climate systems, organizational culture, public trust, infrastructure condition, educational development, and ecological resilience all involve delays. A policy may look successful before its harms appear, or unsuccessful before its benefits mature.

A third limit is adaptation. People, organizations, markets, technologies, and ecosystems respond. When a metric becomes a target, people may change behavior around the metric. When a subsidy changes demand, prices may change. When enforcement increases, avoidance may increase. When an algorithm changes ranking rules, creators adapt content. The system is not passive.

Linear reasoning also fails when it ignores accumulation. Many systems are shaped by stocks: trust, debt, fatigue, knowledge, backlog, infrastructure condition, soil health, atmospheric carbon, social legitimacy, institutional memory, and technical debt. Stocks change over time through flows. If reasoning focuses only on current events, it misses the accumulation that produces future behavior.

The systems question is not simply “What caused this?” It is “What structure produces this pattern over time?” That shift is the difference between linear explanation and systemic understanding.

Back to top ↑

Feedback, Delay, and Nonlinear Response

Feedback is one of the main reasons linear reasoning fails. In a feedback system, an action produces a result that influences future action. Reinforcing feedback amplifies change. Balancing feedback resists change. Delays separate cause from effect, making the system harder to understand. Nonlinear response means that the system may respond weakly at first and strongly later, or strongly at first and weakly later.

Consider organizational workload. A team receives more work. In the short term, people work harder. Output rises. Leaders may conclude that increased pressure works. But over time, fatigue rises. Error rates increase. Rework grows. Turnover begins. Institutional memory declines. Capacity falls. Now the same pressure produces less output and more damage. The initial linear model was incomplete because it ignored feedback and delay.

Consider public trust. An institution faces criticism and responds with messaging. The message may reduce pressure briefly. But if institutional behavior does not change, people may experience the messaging as manipulation. Trust declines further. Future messages become less effective. The intervention changes the feedback environment.

Feedback and delay create several common misperceptions:

• short-term improvement is mistaken for durable success;
• delayed harm is disconnected from the policy that caused it;
• slow structural investments are abandoned before benefits appear;
• oscillation is caused by overreacting to delayed feedback;
• resistance is blamed on people instead of compensating feedback;
• stocks are depleted because their decline is not immediately visible;
• thresholds are crossed before decision-makers recognize danger.

Nonlinear response is especially important. Systems may appear stable until a threshold is crossed. A person may manage workload until burnout accelerates. A community may tolerate burden until trust collapses. An ecosystem may absorb stress until regime shift. A platform may grow until moderation and trust fail. A financial system may appear liquid until confidence breaks.

Feedback awareness changes reasoning. Instead of asking whether an intervention produces an immediate effect, systems thinking asks what feedback the intervention activates, what delays are involved, what stocks are changing, and how the system’s response may change over time.

Back to top ↑

Event Thinking versus Structural Thinking

Event thinking focuses on what happened. Structural thinking focuses on what keeps happening and why. Event thinking asks: Who made the mistake? What caused the outage? Why did the project fail? Why did people resist the policy? Structural thinking asks: What pattern has appeared over time? What feedback loops reproduce it? What incentives make it reasonable? What stocks are being depleted? What assumptions define the problem? What system conditions make this event likely?

Event thinking is useful for immediate response. If a system is failing now, people need to know what happened and how to stabilize it. But event thinking becomes limiting when it treats each event as separate. Repeated events usually indicate structure. If the same kind of mistake happens across teams, the issue is unlikely to be individual carelessness alone. If multiple public programs create administrative burden, the issue is likely institutional design. If every technology rollout creates user confusion, the issue may be workflow, governance, or design practice.

Systems thinking often moves through four levels: events, patterns, structures, and mental models. Events are visible. Patterns show recurrence. Structures explain why patterns persist. Mental models explain why structures are maintained, defended, or misunderstood.

Event thinking often supports blame because events have visible actors. Structural thinking supports redesign because patterns have underlying conditions. This does not remove responsibility. It deepens responsibility. If leaders repeatedly see the same event and fail to change the structure, responsibility shifts upward and outward. The organization can no longer claim surprise.

The key discipline is to treat events as clues. A failure is not only a failure. It is evidence about the system.

Back to top ↑

Cognitive Bias and System Misperception

Cognitive biases affect how people perceive systems. People tend to notice recent events, vivid examples, individual behavior, and immediate causes more easily than delayed, distributed, structural, or statistical patterns. This makes complex systems hard to understand intuitively. The mind is often better at stories of direct agency than at feedback loops, accumulation, and delayed causality.

Several cognitive tendencies are especially relevant. The availability heuristic makes recent or vivid examples feel more important. Fundamental attribution error encourages people to explain behavior through character rather than situation. Confirmation bias makes people favor evidence that supports existing beliefs. Action bias makes intervention feel better than waiting for slow structural effects. Present bias makes short-term outcomes more compelling than long-term consequences. Outcome bias makes successful results seem wise even if they depended on luck or hidden advantage.

System misperception is not simply individual bias. Organizations and institutions amplify bias through metrics, incentives, culture, professional training, hierarchy, and power. A dashboard can make measurable variables feel real while hiding unmeasured burden. A professional discipline can make certain causes more visible than others. A hierarchy can amplify the mental models of leaders while filtering the experience of frontline workers or affected communities.

Cognitive bias does not mean people are foolish. It means human reasoning evolved for environments where direct, immediate, visible causality was often useful. Complex systems require additional tools: maps, models, simulations, diverse perspectives, historical analysis, scenario thinking, and disciplined reflection.

Systems thinking is partly a cognitive discipline. It helps people slow down interpretation, test assumptions, and look for feedback structures that intuition may miss.

Back to top ↑

Organizational Mental Models

Organizations have mental models too. They appear in strategy documents, performance metrics, leadership language, budgeting rules, hiring criteria, meeting routines, customer assumptions, risk frameworks, and informal sayings. An organization’s mental model defines what it believes about work, people, value, quality, speed, risk, authority, learning, and success.

Organizational mental models are powerful because they shape structure. If an organization believes people are mostly motivated by pressure, it will design targets, surveillance, and penalties. If it believes people learn through feedback and autonomy, it will design learning routines, authority, and support. If it believes customers are primarily rational choosers, it may miss trust, emotion, burden, and context. If it believes technology automatically improves efficiency, it may ignore governance, workflow, and hidden labor.

Organizational mental models often become invisible because they are embedded in normal operations. They are not debated every day. They appear as “how we do things here.” A mental model becomes culture when it is repeatedly enacted through decisions, incentives, and stories.

Common organizational mental models include:

• Control model: performance improves when people are monitored and corrected.
• Hero model: success depends on extraordinary individual effort.
• Efficiency model: slack is waste rather than resilience or learning capacity.
• Metric model: what is measured is what matters.
• Technology model: automation solves process problems by speeding them up.
• Communication model: resistance means people do not understand the message.
• Merit model: current success reflects ability more than prior opportunity.
• Stability model: past success indicates future suitability.

For example, if leaders assume employees avoid responsibility, they may centralize decisions. Centralization reduces employee authority. Reduced authority makes employees less likely to act independently. Leaders then interpret passivity as proof that employees avoid responsibility. The mental model has created the evidence that confirms it.

Organizational learning requires surfacing these loops. The question is not only whether the organization’s beliefs are true. The question is whether the organization’s beliefs help create the behavior they claim to describe.

Back to top ↑

Policy Mental Models and Public Systems

Public systems are shaped by policy mental models: assumptions about citizens, institutions, incentives, compliance, need, risk, cost, public value, and responsibility. These assumptions influence laws, eligibility rules, administrative procedures, funding formulas, enforcement systems, evaluation metrics, and service design. A policy can appear technical while carrying a powerful mental model about people and society.

For example, a policy system may assume that stricter verification prevents misuse. That assumption may be partly valid, but it can also create administrative burden, delay, exclusion, nonparticipation, and distrust. A public-health campaign may assume that behavior changes when information improves. That may be true when information is the barrier, but not when access, trust, cost, language, work schedules, housing, or historical harm shape behavior. A workforce policy may assume that job training alone solves unemployment, while ignoring childcare, transportation, discrimination, regional labor demand, health, and care responsibilities.

Policy mental models matter because they decide where responsibility is placed. A deficit model locates failure in individuals or communities. A structural model locates failure in conditions, rules, incentives, and institutions. A market model emphasizes choice and efficiency. A public-value model emphasizes dignity, access, accountability, and shared responsibility. A risk-control model emphasizes prevention of misuse. A trust-and-burden model asks whether the system is accessible and legitimate.

Public systems require special care because policy mental models affect rights, access, dignity, and life chances. A flawed mental model can deny people services, increase surveillance, shift burden, or blame communities for structural harm. Systems thinking asks policymakers to examine the model beneath the policy: What does this design assume about people? What behavior does it make easier or harder? Who carries the cost if the assumption is wrong?

Policy design is never only technical. It is interpretive. It reflects a theory of the system and a theory of the people within it.

Back to top ↑

Power and Problem Definition

Mental models are connected to power because power often determines whose interpretation becomes the official problem definition. A leader may define burnout as a resilience issue. Workers may define it as workload and staffing failure. A public agency may define nonparticipation as lack of awareness. Applicants may define it as administrative burden. A city may define displacement as market change. Residents may define it as policy choice. A platform may define harmful content as user behavior. Communities may define it as incentive design.

The ability to define the problem is one of the most powerful forms of system influence. Once a problem is defined, some solutions become thinkable and others disappear. If poverty is defined as individual failure, the solution becomes discipline, training, or conditional assistance. If poverty is defined as structural insecurity, the solution may include wages, housing, healthcare, childcare, taxation, labor rights, and public investment. If climate change is defined as consumer choice, the solution becomes individual behavior. If it is defined as energy, infrastructure, political economy, and ecological limits, the solution changes dramatically.

Powerful mental models can make structural causes invisible. They can also make marginalized knowledge seem subjective while official models are treated as objective. A community’s lived experience may be dismissed as anecdotal, while a narrow metric is treated as truth. A worker’s warning may be framed as negativity, while a management dashboard defines reality. A patient’s difficulty navigating a system may be framed as noncompliance, while the system’s complexity remains unnamed.

Systems thinking must therefore ask:

• Who defined the problem?
• Who was excluded from the definition?
• What causes are visible in the dominant mental model?
• What causes are hidden?
• Who benefits from this framing?
• Who is blamed by this framing?
• What solutions become impossible under this framing?
• What would the problem look like from the perspective of those carrying the burden?

Problem definition is not a neutral first step. It is already an intervention. A system begins changing when its dominant mental model is challenged by evidence, history, and voices that were previously excluded.

Back to top ↑

Improving Mental Models Through Systems Practice

Mental models can be improved. The goal is not to create a perfect model, because no model can capture every aspect of reality. The goal is to make models more explicit, testable, inclusive, dynamic, and useful for learning. Better mental models help people see feedback, delay, unintended consequences, structural causes, and the limits of their own assumptions.

Several systems practices help improve mental models. Causal-loop diagrams reveal feedback. Stock-flow diagrams reveal accumulation. Behavior-over-time graphs reveal patterns beyond events. Scenario modeling tests assumptions under different conditions. Sensitivity analysis shows which assumptions matter most. Boundary critique asks what and who the model leaves out. Participatory modeling brings different forms of knowledge into the same reasoning process. Reflection routines help organizations examine the assumptions behind decisions.

Improving mental models requires comparison. A single model can become a prison. Multiple models can reveal blind spots. For example, a workforce problem can be modeled through productivity, capacity, burnout, learning, incentives, equity, and institutional memory. Each model sees something different. Systems thinking does not collapse them into one simple story. It asks how they interact.

Improving mental models also requires humility. People must be willing to say: our model may be wrong; our metric may be partial; our experience may not be universal; our expertise may see one layer but miss another; our success may depend on conditions we did not create; our intervention may harm people if the model is incomplete.

A better mental model does not only explain the system. It helps the system learn.

Back to top ↑

Ethics: Blame, Boundaries, and Interpretive Responsibility

Mental models have ethical consequences because they shape blame, responsibility, and repair. A flawed mental model can blame individuals for systemic conditions, treat marginalized communities as problems, justify surveillance or exclusion, ignore historical harm, or design policies that increase burden while claiming neutrality. A mental model is not just a cognitive tool. It is an ethical frame.

Linear reasoning often supports blame because it seeks a direct cause. If someone missed a deadline, blame the person. If someone failed to complete a form, blame the applicant. If a student struggles, blame motivation. If a neighborhood is poor, blame culture. Systems thinking does not deny individual agency, but it refuses to stop at agency when structure is producing predictable outcomes.

Boundary choices are also ethical. Every model includes some things and excludes others. If a policy model includes administrative cost but excludes applicant burden, the system may call itself efficient while shifting labor to the public. If an economic model includes profit but excludes ecological damage, it may call extraction growth. If an organizational model includes output but excludes burnout, it may call depletion productivity. If a technology model includes accuracy but excludes contestability, it may call automation fair while denying people meaningful recourse.

Ethical mental-model analysis asks:

• Who or what is included in the model?
• Who or what is excluded?
• Who is blamed by the model?
• Who is protected by the model?
• What forms of evidence does the model recognize?
• What histories does the model ignore?
• What burdens does the model hide?
• What repair does the model make visible or invisible?
• Who has authority to revise the model?
• What happens if the model is wrong?

Interpretive responsibility means being accountable for the assumptions used to explain and intervene in systems. Leaders, analysts, policymakers, designers, researchers, and institutions should not treat their models as neutral when those models allocate burden, legitimacy, resources, and blame. A model that affects people must be open to challenge by those affected.

Systems thinking becomes ethical when it uses mental models to reduce harm, reveal hidden structure, include excluded knowledge, and support repair rather than blame.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Mental models can be examined through diagrams, simulations, causal models, stock-flow systems, Bayesian updating, scenario analysis, sensitivity testing, and agent-based modeling. The purpose of modeling is not to eliminate judgment. It is to make assumptions visible, test how they behave, and compare alternative explanations.

A simple linear model can be represented as:

A nonlinear system response can be represented as:

A feedback model can be written as:

A mental-model comparison can be represented as:

Model updating can be represented conceptually as:

A boundary critique can be represented as:

Computational modeling can help expose the limits of linear reasoning by showing how delays, feedback, thresholds, and adaptive behavior change outcomes over time. But models can also reinforce bad mental models if their assumptions are hidden. A model should not become an authority that ends conversation. It should become a tool for better inquiry.

Back to top ↑

Python Workflow: Linear Assumptions, Feedback Delay, Boundary Critique, and Mental-Model Diagnostics

The Python workflow below turns mental-model analysis into a small reproducible systems model. It compares four scenarios: linear pressure frame, dashboard and communication frame, feedback and boundary critique frame, and systemic learning and power-aware redesign. It also includes one-at-a-time sensitivity analysis for the systemic learning scenario. The script uses only the Python standard library, writes CSV outputs relative to the article folder, and is designed as a clear starting point for companion repository work.

# mental_models_limits_linear_reasoning_workflow.py
# Dependency-light workflow for mental-model diagnostics:
# linear assumptions, feedback delay, nonlinear response, boundary critique,
# stakeholder inclusion, model updating, intervention-frame comparison,
# and ethical risk scoring.
# Writes outputs relative to the article root.

from __future__ import annotations

from dataclasses import dataclass, replace
from pathlib import Path
import csv
from statistics import mean

ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"


@dataclass
class MentalModelScenario:
    name: str
    linear_assumption_strength: float
    feedback_awareness: float
    delay_awareness: float
    stock_flow_awareness: float
    boundary_inclusion: float
    stakeholder_voice: float
    power_analysis: float
    evidence_updating: float
    intervention_pressure: float
    structural_redesign_strength: float
    uncertainty_humility: float
    metric_quality: float


def clamp(value: float, low: float = 0.0, high: float = 140.0) -> float:
    return max(low, min(high, value))


def run_scenario(scenario: MentalModelScenario, periods: int = 60) -> list[dict[str, object]]:
    problem_pressure = 58.0 + scenario.intervention_pressure * 12.0
    trust_stock = 42.0 + scenario.stakeholder_voice * 16.0
    burden_stock = 42.0 + scenario.linear_assumption_strength * 14.0
    feedback_signal = 38.0 + scenario.feedback_awareness * 18.0
    model_accuracy = 40.0 + scenario.evidence_updating * 16.0
    boundary_gap = 54.0 - scenario.boundary_inclusion * 22.0
    learning_capacity = 34.0 + scenario.uncertainty_humility * 16.0 + scenario.evidence_updating * 10.0
    delayed_effect_stock = 22.0 + scenario.delay_awareness * 4.0
    rows: list[dict[str, object]] = []

    for period in range(periods + 1):
        linear_intervention_effect = clamp(
            scenario.intervention_pressure * 18.0
            + scenario.linear_assumption_strength * 8.0
            - scenario.feedback_awareness * 3.0
            - scenario.delay_awareness * 2.0,
            0.0,
            100.0,
        )

        systems_intervention_effect = clamp(
            scenario.structural_redesign_strength * 18.0
            + scenario.feedback_awareness * 8.0
            + scenario.delay_awareness * 6.0
            + scenario.stock_flow_awareness * 7.0
            + scenario.boundary_inclusion * 6.0
            + scenario.stakeholder_voice * 6.0
            + scenario.power_analysis * 5.0,
            0.0,
            100.0,
        )

        unintended_consequence = clamp(
            scenario.linear_assumption_strength * 12.0
            + scenario.intervention_pressure * 8.0
            + max(0.0, 55.0 - model_accuracy) * 0.12
            + boundary_gap * 0.08
            - scenario.feedback_awareness * 4.0
            - scenario.delay_awareness * 3.0
            - scenario.structural_redesign_strength * 3.0,
            0.0,
            100.0,
        )

        delayed_feedback = clamp(
            delayed_effect_stock * 0.13
            + unintended_consequence * 0.08
            + max(0.0, problem_pressure - 55.0) * 0.05
            - scenario.delay_awareness * 4.0
            - scenario.evidence_updating * 3.0,
            0.0,
            100.0,
        )

        boundary_error = clamp(
            boundary_gap * 0.16
            + max(0.0, 55.0 - scenario.boundary_inclusion * 100.0) * 0.06
            + max(0.0, 55.0 - scenario.stakeholder_voice * 100.0) * 0.06
            - scenario.power_analysis * 4.0,
            0.0,
            100.0,
        )

        metric_distortion = clamp(
            max(0.0, 60.0 - scenario.metric_quality * 100.0) * 0.12
            + scenario.linear_assumption_strength * 6.0
            + scenario.intervention_pressure * 4.0
            - scenario.evidence_updating * 4.0
            - scenario.uncertainty_humility * 3.0,
            0.0,
            100.0,
        )

        model_revision_flow = clamp(
            scenario.evidence_updating * 14.0
            + scenario.uncertainty_humility * 10.0
            + scenario.stakeholder_voice * 9.0
            + scenario.boundary_inclusion * 7.0
            + scenario.power_analysis * 6.0
            + feedback_signal * 0.06
            - metric_distortion * 0.07
            - scenario.linear_assumption_strength * 3.0,
            0.0,
            100.0,
        )

        problem_pressure = clamp(
            problem_pressure
            + unintended_consequence * 0.10
            + delayed_feedback * 0.08
            + burden_stock * 0.05
            - linear_intervention_effect * 0.07
            - systems_intervention_effect * 0.11,
            0.0,
            140.0,
        )

        trust_stock = clamp(
            trust_stock
            + scenario.stakeholder_voice * 1.3
            + scenario.power_analysis * 0.9
            + systems_intervention_effect * 0.035
            - burden_stock * 0.035
            - boundary_error * 0.035
            - metric_distortion * 0.025,
            0.0,
            100.0,
        )

        burden_stock = clamp(
            burden_stock
            + unintended_consequence * 0.09
            + boundary_error * 0.08
            + metric_distortion * 0.05
            - scenario.boundary_inclusion * 1.0
            - scenario.stakeholder_voice * 1.0
            - scenario.structural_redesign_strength * 1.0,
            0.0,
            120.0,
        )

        feedback_signal = clamp(
            feedback_signal
            + scenario.feedback_awareness * 1.1
            + scenario.stakeholder_voice * 0.9
            + scenario.metric_quality * 0.8
            + model_revision_flow * 0.05
            - metric_distortion * 0.06
            - scenario.linear_assumption_strength * 0.5,
            0.0,
            100.0,
        )

        model_accuracy = clamp(
            model_accuracy
            + model_revision_flow * 0.10
            + scenario.feedback_awareness * 0.8
            + scenario.stock_flow_awareness * 0.8
            + scenario.delay_awareness * 0.7
            - boundary_error * 0.06
            - metric_distortion * 0.05,
            0.0,
            100.0,
        )

        boundary_gap = clamp(
            boundary_gap
            + scenario.linear_assumption_strength * 0.7
            - scenario.boundary_inclusion * 1.2
            - scenario.stakeholder_voice * 1.0
            - scenario.power_analysis * 0.8,
            0.0,
            100.0,
        )

        learning_capacity = clamp(
            learning_capacity
            + model_revision_flow * 0.09
            + scenario.uncertainty_humility * 1.0
            + scenario.evidence_updating * 0.9
            - scenario.linear_assumption_strength * 0.5
            - metric_distortion * 0.04,
            0.0,
            100.0,
        )

        delayed_effect_stock = clamp(
            delayed_effect_stock
            + unintended_consequence * 0.08
            + scenario.intervention_pressure * 0.7
            - scenario.delay_awareness * 1.2
            - scenario.structural_redesign_strength * 0.8,
            0.0,
            120.0,
        )

        misperception_risk = clamp(
            scenario.linear_assumption_strength * 18.0
            + boundary_error * 0.18
            + metric_distortion * 0.18
            + delayed_feedback * 0.14
            + max(0.0, 55.0 - model_accuracy) * 0.18
            + max(0.0, 55.0 - trust_stock) * 0.12
            - scenario.uncertainty_humility * 6.0,
            0.0,
            100.0,
        )

        systemic_reasoning_score = clamp(
            model_accuracy * 0.18
            + feedback_signal * 0.16
            + learning_capacity * 0.16
            + trust_stock * 0.14
            + scenario.feedback_awareness * 10.0
            + scenario.boundary_inclusion * 10.0
            + scenario.power_analysis * 8.0
            + scenario.evidence_updating * 8.0
            - misperception_risk * 0.18
            - burden_stock * 0.15
            - boundary_gap * 0.12,
            0.0,
            100.0,
        )

        rows.append({
            "period": period,
            "scenario": scenario.name,
            "problem_pressure": round(problem_pressure, 3),
            "trust_stock": round(trust_stock, 3),
            "burden_stock": round(burden_stock, 3),
            "feedback_signal": round(feedback_signal, 3),
            "model_accuracy": round(model_accuracy, 3),
            "boundary_gap": round(boundary_gap, 3),
            "learning_capacity": round(learning_capacity, 3),
            "delayed_effect_stock": round(delayed_effect_stock, 3),
            "linear_intervention_effect": round(linear_intervention_effect, 3),
            "systems_intervention_effect": round(systems_intervention_effect, 3),
            "unintended_consequence": round(unintended_consequence, 3),
            "delayed_feedback": round(delayed_feedback, 3),
            "boundary_error": round(boundary_error, 3),
            "metric_distortion": round(metric_distortion, 3),
            "misperception_risk": round(misperception_risk, 3),
            "systemic_reasoning_score": round(systemic_reasoning_score, 3),
        })

    return rows


def summarize(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    output: list[dict[str, object]] = []
    for scenario_name in sorted({row["scenario"] for row in rows}):
        subset = [row for row in rows if row["scenario"] == scenario_name]
        final = subset[-1]
        avg_score = mean(float(row["systemic_reasoning_score"]) for row in subset)
        avg_risk = mean(float(row["misperception_risk"]) for row in subset)
        avg_burden = mean(float(row["burden_stock"]) for row in subset)
        avg_boundary = mean(float(row["boundary_gap"]) for row in subset)
        avg_accuracy = mean(float(row["model_accuracy"]) for row in subset)

        if float(final["systemic_reasoning_score"]) >= 65 and float(final["misperception_risk"]) <= 35:
            diagnostic = "mental model is being revised through feedback, boundary critique, and evidence"
        elif avg_risk >= 55:
            diagnostic = "linear misperception is likely driving intervention failure"
        elif avg_boundary >= 55:
            diagnostic = "model boundary excludes important experience, cost, or power"
        elif avg_burden >= 55:
            diagnostic = "reasoning frame is shifting burden onto people outside the model"
        elif avg_accuracy < 45:
            diagnostic = "model accuracy remains too weak for confident intervention"
        elif avg_score >= 55:
            diagnostic = "partial model improvement with remaining misperception risk"
        else:
            diagnostic = "weak evidence of durable mental-model improvement"

        output.append({
            "scenario": scenario_name,
            "final_systemic_reasoning_score": final["systemic_reasoning_score"],
            "final_misperception_risk": final["misperception_risk"],
            "final_model_accuracy": final["model_accuracy"],
            "final_boundary_gap": final["boundary_gap"],
            "final_burden_stock": final["burden_stock"],
            "final_trust_stock": final["trust_stock"],
            "average_systemic_reasoning_score": round(avg_score, 3),
            "average_misperception_risk": round(avg_risk, 3),
            "average_burden_stock": round(avg_burden, 3),
            "average_boundary_gap": round(avg_boundary, 3),
            "average_model_accuracy": round(avg_accuracy, 3),
            "diagnostic": diagnostic,
        })

    return output


def one_at_a_time(base: MentalModelScenario, delta: float = 0.10) -> list[dict[str, object]]:
    base_score = float(run_scenario(base)[-1]["systemic_reasoning_score"])
    parameters = [
        "linear_assumption_strength",
        "feedback_awareness",
        "delay_awareness",
        "stock_flow_awareness",
        "boundary_inclusion",
        "stakeholder_voice",
        "power_analysis",
        "evidence_updating",
        "intervention_pressure",
        "structural_redesign_strength",
        "uncertainty_humility",
        "metric_quality",
    ]

    rows: list[dict[str, object]] = []
    for parameter in parameters:
        for direction in (-1, 1):
            current = getattr(base, parameter)
            revised_value = max(0.0, min(1.0, current + direction * delta))
            revised = replace(base, name=f"{base.name} {parameter} {direction * delta:+.2f}", **{parameter: revised_value})
            revised_score = float(run_scenario(revised)[-1]["systemic_reasoning_score"])
            rows.append({
                "parameter": parameter,
                "delta": direction * delta,
                "base_value": current,
                "revised_value": revised_value,
                "base_final_systemic_reasoning_score": round(base_score, 3),
                "revised_final_systemic_reasoning_score": round(revised_score, 3),
                "score_change": round(revised_score - base_score, 3),
                "absolute_score_change": round(abs(revised_score - base_score), 3),
            })

    return sorted(rows, key=lambda row: float(row["absolute_score_change"]), reverse=True)


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows to write: {path}")
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def main() -> None:
    scenarios = [
        MentalModelScenario("Linear pressure frame", 0.86, 0.18, 0.16, 0.16, 0.18, 0.16, 0.14, 0.20, 0.82, 0.18, 0.18, 0.30),
        MentalModelScenario("Dashboard and communication frame", 0.66, 0.38, 0.30, 0.32, 0.34, 0.30, 0.26, 0.42, 0.68, 0.32, 0.36, 0.52),
        MentalModelScenario("Feedback and boundary critique frame", 0.42, 0.70, 0.66, 0.64, 0.70, 0.68, 0.62, 0.68, 0.48, 0.64, 0.66, 0.68),
        MentalModelScenario("Systemic learning and power-aware redesign", 0.24, 0.84, 0.82, 0.82, 0.86, 0.86, 0.84, 0.84, 0.38, 0.84, 0.84, 0.82),
    ]

    rows: list[dict[str, object]] = []
    for scenario in scenarios:
        rows.extend(run_scenario(scenario))

    write_csv(TABLES / "mental_models_timeseries.csv", rows)
    write_csv(TABLES / "mental_models_summary.csv", summarize(rows))
    write_csv(TABLES / "mental_models_sensitivity_analysis.csv", one_at_a_time(scenarios[-1]))

    print("Mental-model diagnostics workflow complete.")
    print(TABLES / "mental_models_timeseries.csv")


if __name__ == "__main__":
    main()

The workflow is intentionally simple enough to inspect. It shows how linear assumptions, feedback awareness, delay awareness, stock-flow awareness, boundary inclusion, stakeholder voice, power analysis, evidence updating, intervention pressure, structural redesign, uncertainty humility, and metric quality interact over time. It also shows why a reasoning frame should be judged by the pattern it produces, not by how clear it sounds in the first moment. The model is synthetic and illustrative; it supports disciplined inquiry rather than replacing domain expertise, stakeholder evidence, or ethical judgment.

Back to top ↑

R Workflow: Mental-Model Summary and Linear-versus-Systems Visualization

The R workflow reads the Python-generated time-series and sensitivity outputs, creates scenario summaries, and exports base R plots for problem pressure, model accuracy, boundary gap, misperception risk, burden, and systemic reasoning score. It uses only base R so it remains portable across simple local environments.

# mental_models_limits_linear_reasoning_diagnostics.R
# Base R workflow for mental-model summary and linear-versus-systems visualization.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")

if (!dir.exists(tables_dir)) {
  dir.create(tables_dir, recursive = TRUE)
}

if (!dir.exists(figures_dir)) {
  dir.create(figures_dir, recursive = TRUE)
}

timeseries_path <- file.path(tables_dir, "mental_models_timeseries.csv")
sensitivity_path <- file.path(tables_dir, "mental_models_sensitivity_analysis.csv")

if (!file.exists(timeseries_path)) {
  stop(paste("Missing", timeseries_path, "Run the Python workflow first."))
}

data <- read.csv(timeseries_path, stringsAsFactors = FALSE)

last_by_scenario <- do.call(
  rbind,
  lapply(split(data, data$scenario), function(df) df[nrow(df), ])
)

avg_score <- aggregate(systemic_reasoning_score ~ scenario, data = data, FUN = mean)
avg_risk <- aggregate(misperception_risk ~ scenario, data = data, FUN = mean)
avg_burden <- aggregate(burden_stock ~ scenario, data = data, FUN = mean)
avg_boundary <- aggregate(boundary_gap ~ scenario, data = data, FUN = mean)
avg_accuracy <- aggregate(model_accuracy ~ scenario, data = data, FUN = mean)

names(avg_score)[2] <- "average_systemic_reasoning_score"
names(avg_risk)[2] <- "average_misperception_risk"
names(avg_burden)[2] <- "average_burden_stock"
names(avg_boundary)[2] <- "average_boundary_gap"
names(avg_accuracy)[2] <- "average_model_accuracy"

final_fields <- last_by_scenario[, c(
  "scenario",
  "systemic_reasoning_score",
  "misperception_risk",
  "model_accuracy",
  "boundary_gap",
  "burden_stock",
  "trust_stock"
)]

names(final_fields) <- c(
  "scenario",
  "final_systemic_reasoning_score",
  "final_misperception_risk",
  "final_model_accuracy",
  "final_boundary_gap",
  "final_burden_stock",
  "final_trust_stock"
)

summary_table <- Reduce(
  function(x, y) merge(x, y, by = "scenario"),
  list(avg_score, avg_risk, avg_burden, avg_boundary, avg_accuracy, final_fields)
)

summary_table$diagnostic <- ifelse(
  summary_table$final_systemic_reasoning_score >= 65 &
    summary_table$final_misperception_risk <= 35,
  "mental model is being revised through feedback, boundary critique, and evidence",
  ifelse(
    summary_table$average_misperception_risk >= 55,
    "linear misperception is likely driving intervention failure",
    ifelse(
      summary_table$average_boundary_gap >= 55,
      "model boundary excludes important experience, cost, or power",
      ifelse(
        summary_table$average_burden_stock >= 55,
        "reasoning frame is shifting burden onto people outside the model",
        ifelse(
          summary_table$average_model_accuracy < 45,
          "model accuracy remains too weak for confident intervention",
          ifelse(
            summary_table$average_systemic_reasoning_score >= 55,
            "partial model improvement with remaining misperception risk",
            "weak evidence of durable mental-model improvement"
          )
        )
      )
    )
  )
)

summary_table <- summary_table[order(summary_table$final_systemic_reasoning_score, decreasing = TRUE), ]

write.csv(
  summary_table,
  file.path(tables_dir, "mental_models_r_summary.csv"),
  row.names = FALSE
)

if (file.exists(sensitivity_path)) {
  sensitivity <- read.csv(sensitivity_path, stringsAsFactors = FALSE)
  sensitivity_ranked <- sensitivity[order(sensitivity$absolute_score_change, decreasing = TRUE), ]
  write.csv(
    sensitivity_ranked,
    file.path(tables_dir, "mental_models_sensitivity_ranked_r.csv"),
    row.names = FALSE
  )
}

plot_metric <- function(metric, label, file_name) {
  png(file.path(figures_dir, file_name), width = 1200, height = 700)
  scenarios <- unique(data$scenario)
  plot(
    NA,
    xlim = range(data$period),
    ylim = range(data[[metric]], na.rm = TRUE),
    xlab = "Period",
    ylab = label,
    main = paste(label, "by Mental-Model Scenario")
  )
  for (scenario_name in scenarios) {
    subset_data <- data[data$scenario == scenario_name, ]
    lines(subset_data$period, subset_data[[metric]], lwd = 2)
  }
  legend("topleft", legend = scenarios, lwd = 2, cex = 0.8, bty = "n")
  grid()
  dev.off()
}

plot_metric("problem_pressure", "Problem pressure", "problem_pressure_trajectories.png")
plot_metric("model_accuracy", "Model accuracy", "model_accuracy_trajectories.png")
plot_metric("boundary_gap", "Boundary gap", "boundary_gap_trajectories.png")
plot_metric("misperception_risk", "Misperception risk", "misperception_risk_trajectories.png")
plot_metric("burden_stock", "Burden stock", "burden_stock_trajectories.png")
plot_metric("systemic_reasoning_score", "Systemic reasoning score", "systemic_reasoning_score_trajectories.png")

png(file.path(figures_dir, "final_systemic_reasoning_scores.png"), width = 1200, height = 700)
barplot(
  summary_table$final_systemic_reasoning_score,
  names.arg = summary_table$scenario,
  las = 2,
  ylab = "Final systemic reasoning score",
  main = "Final Systemic Reasoning Score by Scenario"
)
grid()
dev.off()

print(summary_table)

This workflow supports the article’s central methodological claim: mental models should be made explicit, compared, tested against behavior over time, and revised when they hide feedback, delay, boundary costs, power, or lived experience. The R outputs help readers compare linear intervention frames with systemic learning frames.

Back to top ↑

GitHub Repository

The companion repository for this article should help readers examine mental models, compare linear and systemic explanations, model feedback and delay, test assumptions, conduct boundary critique, and evaluate how different causal frames produce different intervention choices using synthetic datasets and reproducible workflows.

articles/mental-models-and-the-limits-of-linear-reasoning/
├── python/
│   ├── mental_models_limits_linear_reasoning_workflow.py
│   ├── linear_vs_systemic_model.py
│   ├── feedback_delay_simulation.py
│   ├── mental_model_comparison.py
│   ├── assumption_sensitivity_analysis.py
│   ├── boundary_critique_workflow.py
│   ├── cognitive_bias_signal_analysis.py
│   ├── participatory_model_synthesis.py
│   ├── intervention_frame_comparison.py
│   ├── validation_checks.py
│   └── run_all_mental_model_workflows.py
├── r/
│   ├── mental_models_limits_linear_reasoning_diagnostics.R
│   ├── linear_systems_comparison_plots.R
│   ├── feedback_delay_visualization.R
│   ├── assumption_sensitivity_tables.R
│   ├── boundary_critique_summary.R
│   ├── mental_model_survey_analysis.R
│   ├── intervention_frame_outputs.R
│   └── run_all_mental_model_workflows.R
├── julia/
│   ├── nonlinear_reasoning_dynamics.jl
│   ├── feedback_delay_model.jl
│   └── mental_model_update_simulation.jl
├── sql/
│   ├── schema_mental_models.sql
│   ├── schema_assumptions.sql
│   ├── schema_boundaries.sql
│   ├── schema_causal_claims.sql
│   ├── schema_feedback_loops.sql
│   ├── schema_intervention_frames.sql
│   ├── schema_model_runs.sql
│   └── schema_outputs.sql
├── rust/
│   └── mental_model_diagnostics_cli.rs
├── go/
│   └── assumption_scenario_runner.go
├── cpp/
│   ├── efficient_feedback_sensitivity_scan.cpp
│   └── nonlinear_response_solver.cpp
├── fortran/
│   └── recurrence_linear_vs_feedback_model.f90
├── c/
│   └── low_level_reasoning_model_engine.c
├── docs/
│   ├── modeling_principles.md
│   ├── article_notes.md
│   ├── mental_models_framework.md
│   ├── linear_reasoning_limits.md
│   ├── boundary_critique_template.md
│   ├── diagnostic_questions.md
│   ├── ethics_and_power_notes.md
│   ├── assumptions_and_limitations.md
│   └── responsible_use.md
├── data/
│   ├── synthetic_mental_models.csv
│   ├── synthetic_assumptions.csv
│   ├── synthetic_boundaries.csv
│   ├── synthetic_causal_claims.csv
│   ├── synthetic_feedback_loops.csv
│   ├── synthetic_intervention_frames.csv
│   ├── synthetic_model_runs.csv
│   └── synthetic_outputs.csv
├── outputs/
│   ├── README.md
│   ├── figures/
│   └── tables/
└── notebooks/
    ├── python_mental_models_walkthrough.ipynb
    └── r_linear_reasoning_visualization_placeholder.ipynb

This repository structure supports the article’s central argument: reasoning frameworks should be made explicit, compared, tested, and revised. The data/ folder separates mental models, assumptions, boundaries, causal claims, feedback loops, intervention frames, model runs, and outputs. The python/ and r/ folders support linear-versus-systemic comparison, feedback-delay simulation, assumption sensitivity, boundary critique, cognitive-bias signal analysis, participatory model synthesis, and intervention-frame comparison. The julia folder supports nonlinear reasoning dynamics and mental-model update simulations. The sql folder defines schemas for reasoning assets and model outputs. The lower-level language folders provide scaffolds for diagnostics, scenario execution, sensitivity scanning, recurrence modeling, and low-level simulation.

Back to top ↑

Back to top ↑

Back to top ↑

Why Better Mental Models Matter

Mental models matter because systems are acted upon through interpretation. A flawed model can make harmful action feel reasonable. It can blame people for structural conditions, treat symptoms as causes, ignore delay, miss feedback, hide power, and call short-term relief a solution. Linear reasoning can be useful, but in complex systems it often stops before the most important causality begins.

Systems thinking does not ask people to abandon clarity. It asks them to earn clarity through better reasoning. It asks them to move from events to patterns, from patterns to structure, and from structure to the mental models that keep the structure in place. It asks them to include feedback, stocks, delays, adaptation, boundaries, and power in the way they think.

Better mental models do not guarantee perfect decisions. They create better conditions for learning. They make assumptions visible. They invite correction. They include more experience. They reveal delayed consequences. They expose hidden burdens. They make structural redesign more possible.

The limits of linear reasoning are not a reason to give up on reason. They are a reason to reason more carefully. In a complex world, the quality of our mental models shapes the quality of our interventions. A system cannot be redesigned wisely if it is first misunderstood.

Back to top ↑

Related Articles

• Systems Thinking in Organizations and Learning
• Learning Organizations and Feedback Awareness
• Policy Resistance and Structural Redesign
• Feedback Loops and System Behavior
• Behavior Over Time and Structural Explanation
• Paradigms, Goals, and Deep System Change
• Leverage Points and Places to Intervene in a System
• Systems Thinking in Public Policy

Further Reading

• Senge, Peter M. The Fifth Discipline: The Art and Practice of the Learning Organization. Doubleday/Currency.
• Sterman, John D. Business Dynamics: Systems Thinking and Modeling for a Complex World. Irwin/McGraw-Hill.
• Meadows, Donella H. Thinking in Systems: A Primer. Chelsea Green Publishing.
• Meadows, Donella H. “Leverage Points: Places to Intervene in a System.” The Sustainability Institute.
• Argyris, Chris and Schön, Donald A. Organizational Learning: A Theory of Action Perspective. Addison-Wesley.
• Kahneman, Daniel. Thinking, Fast and Slow. Farrar, Straus and Giroux.
• Tversky, Amos and Kahneman, Daniel. “Judgment under Uncertainty: Heuristics and Biases.” Science.
• Forrester, Jay W. “Counterintuitive Behavior of Social Systems.” Technology Review.
• Johnson-Laird, Philip N. Mental Models: Towards a Cognitive Science of Language, Inference, and Consciousness. Harvard University Press.
• Checkland, Peter. Systems Thinking, Systems Practice. Wiley.

Back to top ↑

References

• Argyris, C. and Schön, D.A. (1978) Organizational Learning: A Theory of Action Perspective. Reading, MA: Addison-Wesley.
• Checkland, P. (1981) Systems Thinking, Systems Practice. Chichester: Wiley.
• Forrester, J.W. (1971) “Counterintuitive Behavior of Social Systems.” Technology Review, 73(3), pp. 52–68. Available at: https://ocw.mit.edu/courses/15-988-system-dynamics-self-study-fall-1998-spring-1999/resources/counterintuitive_behavior_of_social_systems/
• Johnson-Laird, P.N. (1983) Mental Models: Towards a Cognitive Science of Language, Inference, and Consciousness. Cambridge, MA: Harvard University Press.
• Kahneman, D. (2011) Thinking, Fast and Slow. New York: Farrar, Straus and Giroux.
• Meadows, D.H. (1999) “Leverage Points: Places to Intervene in a System.” The Sustainability Institute. Available at: https://donellameadows.org/archives/leverage-points-places-to-intervene-in-a-system/
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green Publishing. Available at: https://www.chelseagreen.com/product/thinking-in-systems/
• Senge, P.M. (1990) The Fifth Discipline: The Art and Practice of the Learning Organization. New York: Doubleday/Currency.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.
• Tversky, A. and Kahneman, D. (1974) “Judgment under Uncertainty: Heuristics and Biases.” Science, 185(4157), pp. 1124–1131. Available at: https://www.science.org/doi/10.1126/science.185.4157.1124

Back to top ↑