Model Assumptions and Boundary Judgment: What Systems Models Include and Exclude

Last Updated June 7, 2026

Model assumptions and boundary judgment are the hidden architecture of systems modeling. Every model simplifies reality. It decides what belongs inside the system, what remains outside, which relationships matter, which variables can stand in for complex phenomena, which data are credible, which time horizon is relevant, which outcomes count, and which uncertainties must be made visible. These choices are not technical details after the model is built. They are part of the model itself.

A systems model can appear precise because it uses equations, simulations, diagrams, code, data, maps, parameters, scenarios, or dashboards. But precision is not the same as truth. A model of infrastructure resilience may include asset age, load, maintenance cost, and failure probability while excluding neighborhood vulnerability, repair access, institutional capacity, climate exposure, and public trust. A model of public health may include disease transmission and hospital capacity while excluding language barriers, insurance, caregiving, transportation, housing, and mistrust. A model of sustainability may include carbon, energy, land, and cost while excluding political feasibility, Indigenous rights, labor conditions, biodiversity, and intergenerational justice.

Assumptions and boundaries determine what the model can see. They also determine what the model cannot see. That is why boundary judgment is one of the most important responsibilities in systems modeling. It is the act of deciding what counts as part of the system, what is treated as external, what is simplified, what is measured, what is ignored, and what consequences follow from those choices.

This article examines model assumptions and boundary judgment as a critical foundation for responsible systems modeling. It explains how assumptions shape model structure, how boundaries create analytical power and blind spots, how simplification differs from distortion, how stakeholders and values enter boundary decisions, how to document assumptions, how to test boundary sensitivity, and how to communicate model limits without undermining model usefulness.

This article covers structural assumptions, parameter assumptions, data assumptions, causal assumptions, scale assumptions, temporal assumptions, behavioral assumptions, scenario assumptions, boundary critique, stakeholder inclusion, model documentation, uncertainty, validation, sensitivity testing, ethics, mathematical framing, R and Python workflows, responsible use, common pitfalls, and authoritative references.

What Are Model Assumptions?

Model assumptions are the explicit or implicit claims that make a model possible. They define how the model represents the system, what variables are included, how variables interact, how parameters are estimated, how data are interpreted, how uncertainty is handled, and how outputs should be read.

Some assumptions are mathematical. A model may assume linear relationships, stable parameters, constant rates, independent errors, equilibrium behavior, or proportional effects. Some assumptions are empirical. A model may assume a dataset is representative, a sensor is accurate, a survey captures the relevant population, or a historical trend can inform the future. Some assumptions are structural. A model may assume one feedback loop dominates, one network captures dependency, or one spatial boundary defines the system. Some assumptions are normative. A model may assume cost, efficiency, resilience, equity, reliability, or growth should be the main outcome.

The most dangerous assumptions are often not the most technical. They are the ones that are never named because they feel obvious to the modeling team, sponsor, institution, discipline, or software environment.

Back to top ↑

What Is Boundary Judgment?

Boundary judgment is the act of deciding what belongs inside the model and what remains outside. It determines the system of interest, the actors included, the time horizon, the spatial scale, the variables, the data sources, the causal mechanisms, the outcomes, and the institutional context.

Boundary judgment is unavoidable because no model can include everything. A model that tries to include everything becomes unusable. But a model that excludes the wrong things becomes misleading. The craft of modeling lies partly in selecting boundaries that are narrow enough to support analysis and broad enough to avoid distortion.

Boundary judgment is not only an analytical choice. It is also an ethical and political choice because model boundaries determine whose reality is represented and whose reality is excluded.

Back to top ↑

Why Assumptions and Boundaries Matter

Assumptions and boundaries matter because they shape model outputs before any calculation begins. A model can be internally consistent and still misleading if its assumptions are weak or its boundaries are inappropriate. A simulation can run correctly while answering the wrong question. A forecast can be accurate within a narrow frame while omitting consequences outside that frame.

In systems modeling, this problem is especially important because complex systems involve feedback, delay, interdependence, emergence, path dependence, thresholds, and cross-scale effects. A boundary that excludes feedback may make an intervention look more effective than it is. A time horizon that ends too early may hide delayed harm. A model that treats institutional behavior as fixed may miss policy resistance. A model that averages across populations may hide distributional burden.

Model quality therefore depends on more than calibration, computation, and visualization. It depends on whether the assumptions and boundaries are appropriate for the question, system, decision context, and affected stakeholders.

Back to top ↑

Models as Purpose-Built Simplifications

All models simplify. That is not a flaw. Simplification is the reason models are useful. A model removes some complexity so that a particular question can be examined. The problem is not simplification itself. The problem is unexamined simplification.

A good simplification preserves the features of the system that matter for the modeling purpose. A bad simplification removes the very mechanisms that produce the behavior of interest. For example, a queue model may reasonably simplify patient characteristics if the purpose is to study average service time. But it may be inappropriate if the purpose is to study unequal access, language barriers, disability access, or differential clinical risk.

The goal is not to build the most complex model possible. The goal is to build the simplest model that is adequate for the purpose, while making its assumptions, boundaries, exclusions, and risks clear.

Back to top ↑

Types of Model Assumptions

Assumptions appear throughout the modeling process. They shape problem framing, system structure, data interpretation, parameter estimation, scenario design, validation, and communication. A responsible model makes these assumptions visible enough to be reviewed, tested, revised, or contested.

Structural Assumptions

Claims about what parts of the system exist, how they connect, and which mechanisms drive behavior.

Causal Assumptions

Claims about how one variable affects another, including direction, strength, delay, threshold, and feedback.

Parameter Assumptions

Claims about numerical values, rates, elasticities, probabilities, capacities, thresholds, and coefficients.

Data Assumptions

Claims about data accuracy, completeness, representativeness, measurement reliability, and missingness.

Boundary Assumptions

Claims about what is inside the model, what is outside, and what is treated as external context.

Scale Assumptions

Claims about the appropriate spatial, temporal, organizational, or analytical scale of the model.

Behavioral Assumptions

Claims about how people, institutions, firms, agencies, ecosystems, or agents respond to incentives, information, stress, or constraints.

Scenario Assumptions

Claims about plausible futures, interventions, shocks, policies, technological change, climate stress, or social response.

Normative Assumptions

Claims about what outcomes matter, whose welfare counts, how tradeoffs are valued, and what counts as success.

Assumptions should not be buried in technical appendices alone. The most consequential assumptions should be visible in the main interpretation of the model.

Back to top ↑

Boundary Choices and System Visibility

Boundaries create visibility. When something is inside the model, it can be measured, simulated, optimized, debated, and used in decision-making. When something is outside the model, it may be treated as background, fixed context, external shock, or irrelevant complication.

This is why boundary choices can become political. If a public policy model includes fiscal cost but excludes household burden, the model privileges one kind of consequence. If an infrastructure model includes asset failure but excludes unequal service disruption, the model privileges engineering reliability over lived resilience. If a climate model includes mitigation cost but excludes avoided harm, the model can distort the meaning of tradeoffs.

Boundary judgment should therefore ask not only “What can we model?” but also “What becomes less visible because we chose this boundary?”

Back to top ↑

What Models Include, Exclude, and Simplify

A systems model makes three major kinds of representational decisions. It includes some parts of the system, excludes others, and simplifies the parts it includes. Each decision can be appropriate or dangerous depending on the model’s purpose.

The question is not whether the model leaves things out. Every model does. The question is whether the exclusions are appropriate, documented, and tested against the model’s intended use.

Back to top ↑

Structural Assumptions

Structural assumptions define how the model represents system organization. They determine whether the system is modeled as stocks and flows, agents and rules, nodes and edges, queues and events, spatial layers, equations, optimization constraints, or hybrid components.

Structural assumptions are especially important because they shape what kinds of behavior the model can produce. A linear model may not produce threshold effects. A model without feedback loops cannot produce feedback-driven policy resistance. A model without heterogeneous agents cannot represent unequal behavior or adaptation. A model without networks cannot represent dependency, bottlenecks, or cascading failure.

Choosing a modeling paradigm is therefore also choosing a theory of what matters in the system.

Back to top ↑

Data and Measurement Assumptions

Data do not enter a model as neutral truth. They are collected through institutions, sensors, surveys, administrative rules, reporting systems, incentives, measurement instruments, classification schemes, and historical conditions. Data reflect what was measured, who was counted, who was missed, and what categories were considered meaningful.

A model may assume data are complete when they are not. It may assume missing data are random when missingness follows geography, race, income, language, disability, institutional access, or political visibility. It may assume a proxy variable represents a concept when the proxy captures only part of it. It may assume historical data reflect the future when policy, climate, technology, behavior, or institutions are changing.

Responsible modeling treats data quality as a systems question. The data-generating system is part of the model’s credibility.

Back to top ↑

Scale, Time, and Resolution Assumptions

Systems models depend heavily on scale. A model can be built at the scale of individuals, households, organizations, neighborhoods, regions, countries, networks, watersheds, ecosystems, or global systems. It can simulate minutes, days, decades, or centuries. It can use fine-grained spatial resolution, aggregate units, detailed agents, or representative averages.

Scale assumptions matter because system behavior often changes across scales. A policy that improves aggregate efficiency may worsen local vulnerability. A short-term intervention may produce long-term dependency. A neighborhood-level risk may disappear in citywide averages. A model that operates at annual time steps may miss daily bottlenecks, seasonal stress, or extreme events.

A model’s scale should match the process being studied, not merely the data that are easiest to obtain.

Back to top ↑

Behavioral and Institutional Assumptions

Many systems models make assumptions about how people and institutions behave. These assumptions may be explicit, such as a rule for household adoption, firm investment, hospital discharge, or agency budgeting. They may also be implicit, such as assuming compliance, rational response, perfect information, or smooth implementation.

Behavioral and institutional assumptions are often where models fail in practice. People may not respond to incentives as expected. Agencies may lack authority. Staff may be overloaded. Communities may distrust institutions. Firms may adapt strategically. Political opposition may delay implementation. Informal systems may absorb or redirect formal policy changes.

Behavioral realism does not require representing every motive or institution in detail. It does require asking whether simplified behavior is adequate for the model’s purpose.

Back to top ↑

Values, Power, and Boundary Critique

Boundary critique is the practice of examining boundary judgments critically. It asks whose purposes, knowledge, values, authority, and consequences shape the model. It is especially important when models are used in public policy, sustainability, infrastructure, health, environment, climate, AI governance, or other domains where technical outputs can affect real people.

Models often appear neutral because they use formal methods. But choices about objectives, outcomes, data, scenarios, thresholds, weights, and excluded consequences often embed values. A model that optimizes efficiency may treat equity as secondary. A model that minimizes cost may discount long-term resilience. A model that maximizes growth may ignore ecological limits. A model that ranks risks may reflect institutional priorities rather than community experience.

Boundary critique does not mean every model must include everything. It means modelers must be honest about how boundaries shape relevance, authority, and consequence.

Back to top ↑

Assumption Documentation

Assumption documentation is one of the most practical tools for responsible systems modeling. A model should include an assumption register that identifies major assumptions, their source, evidence, uncertainty, sensitivity, owner, review status, and potential consequences if wrong.

Documentation should distinguish assumptions that are well supported from assumptions that are uncertain, contested, convenient, inherited, or made for tractability. This distinction matters because not all assumptions carry the same risk. Some assumptions have little effect on outputs. Others can change the model’s conclusions entirely.

An assumption register is not bureaucratic overhead. It is part of model integrity, reproducibility, and accountability.

Back to top ↑

Boundary Sensitivity Analysis

Boundary sensitivity analysis tests whether model conclusions change when boundaries change. This is different from ordinary parameter sensitivity. Parameter sensitivity asks whether outputs change when numerical values change. Boundary sensitivity asks whether outputs change when the model includes or excludes different actors, variables, scales, time horizons, spatial areas, feedback loops, outcomes, or evidence sources.

Boundary sensitivity is especially important when models inform high-stakes decisions. A policy may look attractive under a narrow fiscal boundary but less attractive when distributional harm is included. A climate adaptation plan may look sufficient at the city scale but insufficient for the most exposed neighborhoods. A technology investment may look efficient when labor and privacy consequences are excluded but weaker when they are included.

A conclusion that survives reasonable boundary tests is stronger than a conclusion that depends on one narrow framing.

Back to top ↑

Validation and Assumption Testing

Validation is not only a test of whether model outputs match observed data. It is also a test of whether assumptions are plausible, boundaries are appropriate, mechanisms are credible, and outputs are useful for the intended purpose.

A systems model can be validated in several ways. It can be checked for internal consistency, compared with historical patterns, reviewed by domain experts, tested against known events, evaluated through sensitivity analysis, compared with alternative models, and reviewed by stakeholders who understand the system. No single validation test proves that a model is true. Validation builds confidence within a defined operating domain.

Validation should be communicated as scoped confidence, not proof. A model may be valid for scenario exploration but not prediction. It may be valid for long-term pattern analysis but not operational control. It may be valid for average outcomes but not equity analysis.

Back to top ↑

Relationship to Other Systems Modeling Approaches

Assumptions and boundary judgment apply to every modeling paradigm. Different methods make different assumptions easier to see and different assumptions easier to hide. A responsible systems model must document assumptions regardless of whether it uses system dynamics, agent-based modeling, network analysis, discrete-event simulation, geospatial modeling, AI, or digital twins.

Assumption discipline is the connective tissue of responsible systems modeling. Without it, methods that look rigorous can produce misleading authority.

Back to top ↑

Mathematical Lens: Assumptions, Boundary Sets, and Sensitivity

A model can be represented as a function that maps inputs, parameters, structure, and assumptions into outputs:

A boundary can be represented as a set of included elements:

Boundary sensitivity compares outputs under alternative boundaries:

Parameter sensitivity can be expressed as:

A scenario comparison can include both output performance and uncertainty:

An assumption risk score can combine uncertainty, sensitivity, and consequence:

These equations do not eliminate judgment. They help make judgment explicit, reviewable, and testable.

Back to top ↑

The Assumption and Boundary Judgment Workflow

Assumption and boundary work should be integrated into the modeling process from the beginning. It should not be treated as a final caveat added after results are produced.

1. Define the Model Purpose

Clarify whether the model supports explanation, scenario exploration, prediction, monitoring, optimization, planning, learning, or decision support.

2. Identify the System Boundary

Define the actors, variables, geography, time horizon, institutions, feedback loops, and outcomes included in the model.

3. List Major Exclusions

Document what is left out and why, especially exclusions that could affect interpretation, equity, resilience, or policy consequences.

4. Build an Assumption Register

Record structural, causal, parameter, data, behavioral, scenario, boundary, and value assumptions in plain language.

5. Rate Assumption Risk

Assess each assumption for uncertainty, output sensitivity, and consequence if wrong.

6. Test Sensitive Assumptions

Use sensitivity analysis, scenario tests, alternative parameters, and stress conditions to identify fragile conclusions.

7. Test Alternative Boundaries

Compare narrow and expanded boundaries, different time horizons, spatial scales, stakeholder definitions, and outcome sets.

8. Review with Stakeholders

Invite domain experts, affected groups, practitioners, and decision-makers to challenge assumptions and boundary choices.

9. Communicate Valid Use

Explain what the model can support, what it cannot support, which assumptions matter most, and where uncertainty remains.

10. Update Assumptions Over Time

Revise assumptions as new data, feedback, validation evidence, stakeholder knowledge, or system changes emerge.

Back to top ↑

Strengths and Limitations

Assumption and boundary discipline improves model credibility because it makes hidden choices visible. It also creates a practical basis for sensitivity analysis, validation, stakeholder review, and responsible communication. But it cannot eliminate uncertainty or make modeling purely objective. It helps modelers reason better under uncertainty.

The limitation is not a reason to avoid assumption work. It is the reason assumption work must be proportionate, prioritized, and connected to real model risk.

Back to top ↑

R Workflow: Assumption Sensitivity and Boundary Comparison

The R workflow below uses base R only. It creates synthetic assumptions, evaluates assumption risk, compares boundary scenarios, and exports sensitivity-style diagnostics. It is designed to show how assumption documentation can become part of a reproducible modeling workflow.

# model_assumptions_boundary_judgment_workflow.R
# Base R workflow:
# assumption risk scoring and boundary scenario comparison.
#
# Suggested repository placement:
# articles/model-assumptions-and-boundary-judgment/r/model_assumptions_boundary_judgment_workflow.R

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 <- normalizePath(getwd(), mustWork = TRUE)
}

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

dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

assumptions <- data.frame(
  assumption_id = c("A1", "A2", "A3", "A4", "A5", "A6"),
  category = c("boundary", "data", "parameter", "behavioral", "scenario", "normative"),
  assumption = c(
    "Community disruption is outside the core infrastructure boundary.",
    "Inspection records are representative of true asset condition.",
    "Annual degradation rate remains stable.",
    "Users comply with service changes after implementation.",
    "Extreme rainfall increases by 20 percent.",
    "Cost minimization is weighted more heavily than distributional equity."
  ),
  uncertainty = c(0.80, 0.55, 0.40, 0.70, 0.65, 0.75),
  sensitivity = c(0.75, 0.60, 0.85, 0.50, 0.80, 0.90),
  consequence = c(0.90, 0.70, 0.65, 0.60, 0.85, 0.95)
)

assumptions$risk_score <- assumptions$uncertainty * assumptions$sensitivity * assumptions$consequence

assumptions$risk_label <- ifelse(
  assumptions$risk_score >= 0.45,
  "high",
  ifelse(assumptions$risk_score >= 0.25, "moderate", "lower")
)

boundary_scenarios <- data.frame(
  boundary = c(
    "narrow_asset_boundary",
    "expanded_service_boundary",
    "community_resilience_boundary",
    "long_horizon_boundary"
  ),
  capital_cost = c(0.80, 0.72, 0.65, 0.60),
  service_reliability = c(0.60, 0.75, 0.78, 0.82),
  equity_performance = c(0.35, 0.55, 0.85, 0.70),
  long_term_resilience = c(0.50, 0.65, 0.78, 0.90)
)

boundary_scenarios$composite_score <-
  0.20 * boundary_scenarios$capital_cost +
  0.30 * boundary_scenarios$service_reliability +
  0.25 * boundary_scenarios$equity_performance +
  0.25 * boundary_scenarios$long_term_resilience

boundary_scenarios <- boundary_scenarios[order(-boundary_scenarios$composite_score), ]

validation_checks <- data.frame(
  check = c(
    "assumption_register_created",
    "risk_scores_between_zero_and_one",
    "boundary_scenarios_created",
    "composite_scores_between_zero_and_one"
  ),
  passed = c(
    nrow(assumptions) > 0,
    all(assumptions$risk_score >= 0 & assumptions$risk_score <= 1),
    nrow(boundary_scenarios) > 0,
    all(boundary_scenarios$composite_score >= 0 & boundary_scenarios$composite_score <= 1)
  )
)

write.csv(
  assumptions,
  file.path(tables_dir, "r_assumption_register.csv"),
  row.names = FALSE
)

write.csv(
  boundary_scenarios,
  file.path(tables_dir, "r_boundary_scenario_comparison.csv"),
  row.names = FALSE
)

write.csv(
  validation_checks,
  file.path(tables_dir, "r_assumption_boundary_validation_checks.csv"),
  row.names = FALSE
)

png(file.path(figures_dir, "r_assumption_risk_scores.png"), width = 1000, height = 700)
barplot(
  assumptions$risk_score,
  names.arg = assumptions$assumption_id,
  ylab = "Assumption Risk Score",
  xlab = "Assumption ID",
  main = "Assumption Risk: Uncertainty × Sensitivity × Consequence"
)
grid()
dev.off()

print(assumptions)
print(boundary_scenarios)
print(validation_checks)
cat("R assumption and boundary judgment workflow complete.\n")

This workflow demonstrates how assumptions can be scored for uncertainty, sensitivity, and consequence, then compared against alternative boundary choices. A professional workflow would add stakeholder review, evidence grading, version control, and formal sensitivity analysis.

Back to top ↑

Python Workflow: Assumption Register and Boundary Scenario Testing

The Python workflow below uses only the standard library. It creates an assumption register, scores assumption risk, compares boundary scenarios, generates validation checks, and exports tables for documentation and review.

#!/usr/bin/env python3
"""
Model assumptions and boundary judgment workflow.

Dependency-light workflow demonstrating:

1. Assumption register creation
2. Assumption risk scoring
3. Boundary scenario comparison
4. Validation checks
5. Documentation-friendly exports

All data are synthetic.
"""

from __future__ import annotations

from pathlib import Path
import csv


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


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}")

    fieldnames: list[str] = []
    for row in rows:
        for key in row:
            if key not in fieldnames:
                fieldnames.append(key)

    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


def risk_label(score: float) -> str:
    if score >= 0.45:
        return "high"
    if score >= 0.25:
        return "moderate"
    return "lower"


def main() -> None:
    assumptions = [
        {
            "assumption_id": "A1",
            "category": "boundary",
            "assumption": "Community disruption is outside the core infrastructure boundary.",
            "source": "model_scope_choice",
            "uncertainty": 0.80,
            "sensitivity": 0.75,
            "consequence": 0.90,
        },
        {
            "assumption_id": "A2",
            "category": "data",
            "assumption": "Inspection records are representative of true asset condition.",
            "source": "administrative_data",
            "uncertainty": 0.55,
            "sensitivity": 0.60,
            "consequence": 0.70,
        },
        {
            "assumption_id": "A3",
            "category": "parameter",
            "assumption": "Annual degradation rate remains stable.",
            "source": "historical_calibration",
            "uncertainty": 0.40,
            "sensitivity": 0.85,
            "consequence": 0.65,
        },
        {
            "assumption_id": "A4",
            "category": "behavioral",
            "assumption": "Users comply with service changes after implementation.",
            "source": "implementation_assumption",
            "uncertainty": 0.70,
            "sensitivity": 0.50,
            "consequence": 0.60,
        },
        {
            "assumption_id": "A5",
            "category": "scenario",
            "assumption": "Extreme rainfall increases by 20 percent.",
            "source": "stress_scenario",
            "uncertainty": 0.65,
            "sensitivity": 0.80,
            "consequence": 0.85,
        },
        {
            "assumption_id": "A6",
            "category": "normative",
            "assumption": "Cost minimization is weighted more heavily than distributional equity.",
            "source": "objective_function_choice",
            "uncertainty": 0.75,
            "sensitivity": 0.90,
            "consequence": 0.95,
        },
    ]

    for row in assumptions:
        score = float(row["uncertainty"]) * float(row["sensitivity"]) * float(row["consequence"])
        row["risk_score"] = round(score, 6)
        row["risk_label"] = risk_label(score)

    boundary_scenarios = [
        {
            "boundary": "narrow_asset_boundary",
            "capital_cost": 0.80,
            "service_reliability": 0.60,
            "equity_performance": 0.35,
            "long_term_resilience": 0.50,
        },
        {
            "boundary": "expanded_service_boundary",
            "capital_cost": 0.72,
            "service_reliability": 0.75,
            "equity_performance": 0.55,
            "long_term_resilience": 0.65,
        },
        {
            "boundary": "community_resilience_boundary",
            "capital_cost": 0.65,
            "service_reliability": 0.78,
            "equity_performance": 0.85,
            "long_term_resilience": 0.78,
        },
        {
            "boundary": "long_horizon_boundary",
            "capital_cost": 0.60,
            "service_reliability": 0.82,
            "equity_performance": 0.70,
            "long_term_resilience": 0.90,
        },
    ]

    for row in boundary_scenarios:
        composite_score = (
            0.20 * float(row["capital_cost"])
            + 0.30 * float(row["service_reliability"])
            + 0.25 * float(row["equity_performance"])
            + 0.25 * float(row["long_term_resilience"])
        )
        row["composite_score"] = round(composite_score, 6)

    boundary_scenarios.sort(key=lambda item: float(item["composite_score"]), reverse=True)

    category_summary: dict[str, dict[str, object]] = {}

    for row in assumptions:
        category = str(row["category"])
        if category not in category_summary:
            category_summary[category] = {
                "category": category,
                "assumption_count": 0,
                "total_risk_score": 0.0,
                "high_risk_count": 0,
            }

        category_summary[category]["assumption_count"] += 1
        category_summary[category]["total_risk_score"] += float(row["risk_score"])
        if row["risk_label"] == "high":
            category_summary[category]["high_risk_count"] += 1

    category_rows = []

    for row in category_summary.values():
        count = int(row["assumption_count"])
        category_rows.append({
            "category": row["category"],
            "assumption_count": count,
            "average_risk_score": round(float(row["total_risk_score"]) / max(count, 1), 6),
            "high_risk_count": row["high_risk_count"],
        })

    validation_rows = [
        {
            "check": "assumption_register_created",
            "passed": len(assumptions) > 0,
            "value": len(assumptions),
        },
        {
            "check": "risk_scores_between_zero_and_one",
            "passed": all(0 <= float(row["risk_score"]) <= 1 for row in assumptions),
            "value": "all_risk_scores_checked",
        },
        {
            "check": "boundary_scenarios_created",
            "passed": len(boundary_scenarios) > 0,
            "value": len(boundary_scenarios),
        },
        {
            "check": "composite_scores_between_zero_and_one",
            "passed": all(0 <= float(row["composite_score"]) <= 1 for row in boundary_scenarios),
            "value": "all_boundary_scores_checked",
        },
    ]

    write_csv(TABLES / "python_assumption_register.csv", assumptions)
    write_csv(TABLES / "python_assumption_category_summary.csv", category_rows)
    write_csv(TABLES / "python_boundary_scenario_comparison.csv", boundary_scenarios)
    write_csv(TABLES / "python_assumption_boundary_validation_checks.csv", validation_rows)

    print("Model assumptions and boundary judgment workflow complete.")
    print(TABLES / "python_boundary_scenario_comparison.csv")


if __name__ == "__main__":
    main()

This workflow demonstrates a practical assumption discipline: list assumptions, rate their uncertainty, sensitivity, and consequence, compare boundary scenarios, and export results for review. The point is not to mechanize judgment. It is to make judgment visible.

Back to top ↑

GitHub Repository

Back to top ↑

Common Pitfalls

Model assumptions and boundary judgments can fail in predictable ways. The most common failure is not that a model has assumptions. Every model does. The failure is that assumptions remain hidden, untested, undocumented, or misrepresented as neutral facts.

The central correction is disciplined humility: make the model useful without pretending that its assumptions are reality.

Back to top ↑

Conclusion

Model assumptions and boundary judgment determine what a systems model can clarify and what it may distort. They define what the model includes, excludes, simplifies, measures, values, and communicates. They shape outputs before the first simulation is run.

Assumptions are not a weakness. They are necessary. Without assumptions, there is no model. But assumptions must be visible, testable, documented, and proportionate to the model’s purpose. Boundary choices are also necessary. No model can include everything. But boundaries must be examined because they determine whose realities, risks, causes, and consequences count.

The strongest systems models are not those that pretend to be assumption-free. They are those that make their assumptions explicit, test sensitive claims, compare alternative boundaries, invite review, communicate uncertainty, and limit conclusions to the model’s valid scope. They treat modeling as structured judgment rather than mechanical certainty.

Boundary judgment is therefore both technical and ethical. It asks what system is being represented, who is affected, what knowledge counts, what consequences matter, and what the model should not be used to claim. Responsible systems modeling begins there.

Back to top ↑

Related Articles

• Systems Modeling
• What Is Systems Modeling?
• Core Principles of Systems Modeling
• Calibration and Validation of Models
• Uncertainty and Model Interpretation
• Sensitivity Analysis in Systems Models
• Participatory Modeling and Stakeholder Systems
• When Systems Models Clarify and When They Distort
• Ethics, Power, and Systems Modeling
• Communicating Model Results Responsibly
• Public Policy Modeling
• Geospatial Systems Modeling

Further Reading

• Ulrich, W. (2005) A Mini-Primer of Critical Systems Heuristics. Available at: https://wulrich.com/csh.html.
• Gates, E. (2023) ‘Critical Systems Heuristics’, Journal of Systems Thinking. Available at: https://www.scienceopen.com/hosted-document?doi=10.54120%2Fjost.0000020.
• National Research Council. (2012) Assessing the Reliability of Complex Models: Mathematical and Statistical Foundations of Verification, Validation, and Uncertainty Quantification. Washington, DC: National Academies Press. Available at: https://www.nationalacademies.org/read/13395/chapter/7.
• Oreskes, N., Shrader-Frechette, K. and Belitz, K. (1994) ‘Verification, validation, and confirmation of numerical models in the Earth sciences’, Science, 263(5147), pp. 641–646.
• Box, G.E.P. (1976) ‘Science and statistics’, Journal of the American Statistical Association, 71(356), pp. 791–799.
• Enderling, H. and Wolkenhauer, O. (2021) ‘Are all models wrong?’, Computational and Systems Oncology. Available at: https://pmc.ncbi.nlm.nih.gov/articles/PMC7880041/.
• Saltelli, A., Tarantola, S., Campolongo, F. and Ratto, M. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Saltelli, A., et al. (2020) ‘Five ways to ensure that models serve society: A manifesto’, Nature, 582, pp. 482–484.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green.
• Checkland, P. and Scholes, J. (1990) Soft Systems Methodology in Action. Chichester: Wiley.
• Midgley, G. (2000) Systemic Intervention: Philosophy, Methodology, and Practice. New York: Kluwer Academic/Plenum.
• Thacker, B.H., Doebling, S.W., Hemez, F.M., Anderson, M.C., Pepin, J.E. and Rodriguez, E.A. (2004) Concepts of Model Verification and Validation. Available at: https://www.osti.gov/servlets/purl/835920.

Back to top ↑

References

• Box, G.E.P. (1976) ‘Science and statistics’, Journal of the American Statistical Association, 71(356), pp. 791–799.
• Checkland, P. and Scholes, J. (1990) Soft Systems Methodology in Action. Chichester: Wiley.
• Enderling, H. and Wolkenhauer, O. (2021) ‘Are all models wrong?’, Computational and Systems Oncology. Available at: https://pmc.ncbi.nlm.nih.gov/articles/PMC7880041/.
• Gates, E. (2023) ‘Critical Systems Heuristics’, Journal of Systems Thinking. Available at: https://www.scienceopen.com/hosted-document?doi=10.54120%2Fjost.0000020.
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green.
• Midgley, G. (2000) Systemic Intervention: Philosophy, Methodology, and Practice. New York: Kluwer Academic/Plenum.
• National Research Council. (2012) Assessing the Reliability of Complex Models: Mathematical and Statistical Foundations of Verification, Validation, and Uncertainty Quantification. Washington, DC: National Academies Press. Available at: https://www.nationalacademies.org/read/13395/chapter/7.
• Oreskes, N., Shrader-Frechette, K. and Belitz, K. (1994) ‘Verification, validation, and confirmation of numerical models in the Earth sciences’, Science, 263(5147), pp. 641–646.
• Saltelli, A., Tarantola, S., Campolongo, F. and Ratto, M. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Saltelli, A., et al. (2020) ‘Five ways to ensure that models serve society: A manifesto’, Nature, 582, pp. 482–484.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.
• Thacker, B.H., Doebling, S.W., Hemez, F.M., Anderson, M.C., Pepin, J.E. and Rodriguez, E.A. (2004) Concepts of Model Verification and Validation. Available at: https://www.osti.gov/servlets/purl/835920.
• Ulrich, W. (2005) A Mini-Primer of Critical Systems Heuristics. Available at: https://wulrich.com/csh.html.

Back to top ↑