System Boundaries and Problem Framing

Last Updated June 1, 2026

Every systems analysis begins by drawing a boundary. The boundary determines what counts as part of the system, what counts as context, what counts as a cause, what counts as a consequence, whose experience is included, whose burden is ignored, and what kind of intervention appears reasonable. A boundary is not just a technical choice. It is an interpretive, ethical, political, and methodological act.

Problem framing is the companion to boundary-setting. To frame a problem is to define what kind of problem it is, what evidence matters, who the relevant actors are, what time horizon should be considered, what harms count, and what forms of action are legitimate. A transportation problem can be framed as traffic congestion, public mobility, land-use failure, emissions policy, disability access, household cost, regional inequality, or climate adaptation. Each frame reveals something. Each frame also hides something.

This article explains why system boundaries and problem framing are foundational to systems thinking. It examines how boundaries shape causality, evidence, accountability, ethics, intervention, measurement, and governance. It also shows why narrow boundaries often produce shallow solutions, why overly broad boundaries can paralyze action, and why responsible systems inquiry requires boundary critique: the disciplined practice of asking what has been included, what has been excluded, and what difference those choices make.

Why Boundaries Matter

A system boundary defines what is being studied. It separates the system from its environment, the primary problem from its surrounding conditions, and the focal question from the larger world in which it is embedded. Boundaries make analysis possible because no inquiry can include everything. But boundaries also shape what the inquiry can see.

A boundary determines which causes are recognized. If a public-health analysis includes only hospitals, then emergency-room overcrowding may appear to be a hospital management problem. If the boundary expands to include primary care, housing, chronic illness, transportation, insurance, environmental exposure, staffing, and public-health capacity, the same problem becomes a broader systems problem. The event is the same. The explanation changes because the boundary changes.

A boundary also determines which consequences count. A policy may appear successful if the boundary includes only budget savings, but harmful if it includes unpaid care work, administrative burden, service delay, public trust, health outcomes, or ecological damage. A technology may appear efficient if the boundary includes only user engagement and platform revenue, but harmful if it includes energy use, labor conditions, misinformation, surveillance, data extraction, and democratic risk.

Boundaries matter because they influence intervention. A narrow boundary often produces narrow fixes. A broad boundary may reveal structural causes, but it can also make the problem seem too large to act upon. Good systems thinking does not simply draw the largest possible boundary. It draws a boundary appropriate to the question, then tests that boundary against evidence, stakeholders, consequences, and ethics.

The purpose of boundary-setting is not to find a perfect boundary. No such boundary exists. The purpose is to make the boundary explicit enough to examine. A hidden boundary becomes an unchallenged assumption. An explicit boundary becomes a subject of inquiry.

Back to top ↑

Problem Framing as Systems Interpretation

Problem framing defines what kind of problem a situation is understood to be. The frame determines what questions are asked, what evidence is collected, what expertise is valued, what solutions are considered, and what forms of accountability become possible. Problem framing is therefore not a preliminary step before systems thinking. It is already part of systems thinking.

Consider urban transportation. If the problem is framed as congestion, the likely solutions may include road expansion, signal timing, parking management, and traffic-flow optimization. If it is framed as mobility, the solution space expands to public transit, walking, cycling, disability access, land use, housing location, work schedules, and service distribution. If it is framed as climate policy, the focus shifts toward emissions, vehicle miles traveled, electrification, mode shift, and regional planning. If it is framed as justice, the analysis asks who has access to safe, affordable, reliable movement and who bears the harms of transportation systems.

The frame does not merely describe the problem. It helps create the problem as an object of action. A problem framed as individual behavior invites education, discipline, or incentives. A problem framed as infrastructure invites investment, maintenance, redesign, or standards. A problem framed as governance invites accountability, rule change, transparency, and institutional reform. A problem framed as historical injustice invites repair, redistribution, and recognition.

Systems thinking asks several framing questions:

• What is the problem being called?
• Who defined it that way?
• What evidence supports that frame?
• What alternative frames are possible?
• What solutions become obvious under this frame?
• What solutions become invisible?
• Who benefits from the dominant frame?
• Who is harmed or excluded by it?

Problem framing is especially important when systems are complex, contested, and value-laden. Public safety, homelessness, climate adaptation, school achievement, infrastructure failure, public health, algorithmic governance, and institutional trust are not merely technical problems. They are problems whose meaning depends on values, histories, evidence, and power. Different frames can lead to different interventions even when everyone agrees that the visible condition is serious.

Responsible systems thinking does not pretend to frame problems from nowhere. It recognizes framing as a situated act. It then makes that act transparent enough to question.

Back to top ↑

Inside, Outside, Context, and Environment

To draw a boundary is to distinguish the system from its environment. But the environment is not irrelevant. It is the surrounding field of conditions, constraints, shocks, opportunities, institutions, ecosystems, markets, histories, and actors that influence the system without necessarily being treated as part of it.

This distinction is useful, but it can also mislead. What appears to be external may be deeply connected. A factory may treat pollution as an externality, but the surrounding community experiences it as part of the system’s operation. A platform may treat user mental health as outside its business model, but engagement design may influence attention, behavior, and wellbeing. A school may treat housing instability as outside its educational mission, but housing affects attendance, concentration, health, and family stress.

Systems thinking therefore treats the inside-outside distinction as provisional. The boundary should be tested. If something outside the boundary strongly affects system behavior, perhaps it should be included. If something inside the boundary is included only because of organizational convenience, perhaps the boundary should be revised. If the system exports harm across the boundary, the boundary may be hiding responsibility.

Context is not background decoration. It can be causal. A hospital’s performance may depend on housing conditions, insurance rules, workforce pipelines, disease burden, public transportation, and public-health infrastructure. A water system may depend on watershed health, climate trends, land use, maintenance funding, regulatory enforcement, and household affordability. A technology system may depend on data labor, energy infrastructure, legal standards, user behavior, and platform economics.

Boundary-setting must therefore distinguish among several categories:

• Core system: the focal elements and relationships being studied directly.
• System environment: surrounding conditions that influence the system.
• Externalized consequences: harms or costs pushed outside the analytical frame.
• Linked systems: adjacent systems that exchange resources, information, risk, or authority.
• Excluded stakeholders: people or communities affected by the system but not included in its decision structure.

The boundary is an analytical tool. It should not become a moral shield. A system cannot ethically avoid responsibility for consequences simply by defining them as external.

Back to top ↑

Boundary Judgments and Their Consequences

A boundary judgment is a decision about what belongs in the analysis and what does not. Boundary judgments may be explicit or implicit. They may be made by researchers, policymakers, managers, engineers, funders, regulators, consultants, community members, or institutions. They may be shaped by data availability, legal authority, budget constraints, professional training, political pressure, ideology, or habit.

Boundary judgments matter because they influence evidence. If only quantitative indicators are included, lived experience may be excluded. If only current costs are included, future risk may be ignored. If only formal institutions are included, informal labor and community networks may disappear. If only market transactions are included, ecological regeneration and unpaid care may be treated as free.

Boundary judgments also influence accountability. A narrow boundary can assign responsibility to frontline actors while excluding those who designed the rules, underfunded the system, chose the metrics, or created the incentives. A broader boundary can reveal distributed responsibility, but it must still remain specific enough to guide action.

Boundary judgments are unavoidable. The goal is not to eliminate them but to make them contestable. A strong systems analysis should be able to say: here is the boundary we drew, here is why we drew it, here is what it includes, here is what it excludes, here is how the conclusion changes if the boundary changes, and here are the ethical risks of the chosen frame.

This is the practice of boundary critique. It is one of the most important safeguards against shallow systems analysis.

Back to top ↑

Scale, Level, and Time Horizon

Boundaries are not only spatial. They are also scalar and temporal. A systems analysis must decide which level of the system is being studied and over what time horizon. The same issue can look different depending on whether the boundary is local, regional, national, global, organizational, ecological, technical, historical, or intergenerational.

Scale determines what causes become visible. A household energy-burden problem may appear to be an individual affordability issue at one scale, a housing-quality issue at another scale, a utility-regulation issue at another, and a climate-transition issue at another. A workplace burnout problem may appear to be individual time management at one level, team coordination at another, organizational design at another, labor-market pressure at another, and cultural ideology at another.

Time horizon is equally important. Short time horizons often privilege efficiency, immediate output, quarterly performance, election cycles, emergency response, and visible repair. Longer time horizons reveal accumulation, depletion, maintenance, trust, ecological change, infrastructure life cycles, learning, intergenerational justice, and delayed risk. A solution that appears efficient over one year may be destructive over twenty. A reform that appears costly now may prevent much greater harm later.

Scale and time can produce conflicting interpretations. A local intervention may succeed locally while worsening regional inequality. A short-term budget cut may look fiscally responsible while increasing long-term maintenance costs. A technical optimization may improve immediate performance while creating future fragility. A climate adaptation project may protect one area while displacing water, heat, or risk elsewhere.

Systems thinking asks analysts to move across levels:

• What does the problem look like at the individual level?
• What does it look like at the household or community level?
• What does it look like at the organizational level?
• What does it look like at the infrastructure or network level?
• What does it look like at the policy or governance level?
• What does it look like at the ecological or planetary level?
• What does it look like over months, years, decades, or generations?

No single level explains everything. But choosing the wrong level can make the right answer impossible. A problem produced by regional housing markets cannot be solved only through individual budgeting advice. A climate problem cannot be solved only through consumer choice. A governance problem cannot be solved only through technical dashboards. A public-health problem cannot be solved only inside hospitals.

Scale is part of causality. Time is part of responsibility.

Back to top ↑

Stakeholders, Voice, and Lived Experience

Boundary-setting determines who counts as a stakeholder. In many systems, the people most affected by decisions are not the people who define the problem. This creates a serious risk: the system can be analyzed from the standpoint of those who govern it rather than those who live inside its consequences.

Stakeholder inclusion is not merely a procedural courtesy. It is an epistemic issue. People in different positions know different things about the system. Frontline workers may know where procedures fail. Residents may know where flooding actually occurs. Patients may know where access breaks down. Students may know how disciplinary systems feel. Maintenance workers may know which assets are fragile. Community organizations may know where formal data misses reality.

Systems thinking should therefore treat lived experience as evidence, not as anecdotal decoration. Lived experience can reveal hidden costs, informal workarounds, exclusion, administrative burden, fear, distrust, adaptation, and harm that formal metrics may miss. At the same time, stakeholder knowledge should be integrated carefully with technical, historical, institutional, ecological, and quantitative evidence. No single standpoint sees the whole system.

Boundary critique asks:

• Who is affected by the system?
• Who has authority over it?
• Who benefits from the current boundary?
• Who is excluded from problem definition?
• Who provides unpaid or invisible support?
• Who absorbs risk when the system fails?
• Who can contest the frame?
• Who can change the structure?

Stakeholder inclusion can also reveal conflicting frames. A public agency may frame a process as efficient because average processing time has declined. Residents may frame the same process as burdensome because documentation requirements, digital access barriers, language barriers, and appeal procedures have intensified. A hospital may frame discharge as successful when a patient leaves the facility. A family may frame the same discharge as unsafe if home care, transportation, medication access, and housing conditions are not adequate.

The point is not that every stakeholder claim is automatically correct. The point is that a systems boundary without stakeholder critique is likely to reflect institutional convenience. Responsible systems thinking asks who has been invited into the frame and who has been left outside it.

Back to top ↑

Externalities and Hidden Costs

An externality is a cost or benefit generated by a system but not fully counted within the system’s decision-making framework. Externalities are boundary problems. They arise when the analytical, financial, legal, or moral boundary is narrower than the consequences of the system’s behavior.

Pollution is a classic example. A company may count production revenue and operating costs while excluding harm to air, water, soil, health, biodiversity, and surrounding communities. The harm is treated as external to the business calculation, but it is not external to reality. It is external only because the boundary has been drawn that way.

Many systems externalize costs:

• Organizations externalize burnout onto workers and families.
• Platforms externalize misinformation and attention harms onto users and societies.
• Infrastructure systems externalize deferred maintenance onto future users.
• Supply chains externalize labor exploitation onto distant workers.
• Housing markets externalize displacement onto households and communities.
• Public agencies externalize administrative burden onto people seeking services.
• Economic systems externalize ecological damage onto future generations and nonhuman life.

Externalities are not always accidental. They can be designed into systems through accounting rules, legal categories, political influence, data gaps, fragmented jurisdiction, and weak accountability. A system can appear efficient precisely because it does not count the burdens it produces.

Boundary critique asks whether the system’s definition of cost is honest. It also asks whether the boundary aligns with responsibility. If a system produces harm, the harm does not disappear because it is excluded from the metric. Exclusion may make the system easier to manage, but it makes the analysis less truthful.

In sustainability, governance, public policy, and institutional design, externalities are among the strongest reasons to use systems thinking. They reveal the moral danger of narrow success. A system can meet its targets while damaging the world that sustains it.

Back to top ↑

Power, Expertise, and Problem Ownership

Problem framing is shaped by power. The people and institutions with authority often define the problem, select the evidence, choose the boundary, commission the analysis, set the metrics, and approve the intervention. This does not mean their frame is always wrong. It means their frame is never neutral.

Power determines what counts as expertise. Engineers may define an infrastructure problem technically. Economists may define it financially. Managers may define it operationally. Lawyers may define it through liability. Communities may define it through lived harm. Ecologists may define it through long-term regeneration. Each perspective may reveal part of the system. The danger arises when one perspective becomes the whole frame and other forms of knowledge are dismissed.

Power also determines problem ownership. A problem assigned to an individual becomes a matter of behavior. A problem assigned to a department becomes a matter of management. A problem assigned to a market becomes a matter of incentives. A problem assigned to governance becomes a matter of rules and accountability. A problem assigned to history becomes a matter of repair. The frame directs responsibility.

This is why systems thinking must ask who has authority to define the system. In many cases, those most harmed by a system have the least ability to define the problem. Communities affected by pollution may be told the issue is economic development. Workers experiencing burnout may be told the issue is resilience. Students affected by exclusionary discipline may be told the issue is behavior. Users affected by algorithmic harm may be told the issue is personalization. Patients facing access barriers may be told the issue is compliance.

Boundary critique does not reject professional expertise. It places expertise inside a broader field of accountability. Technical expertise is essential for many systems. But technical expertise alone cannot determine which harms matter, whose future counts, how risk should be distributed, or what kind of system is legitimate.

A responsible systems frame should be able to answer:

• Who defined the problem?
• Who funded or authorized the analysis?
• Whose categories organize the evidence?
• Whose language shapes the diagnosis?
• Whose alternatives were excluded early?
• Who has the power to act on the conclusion?
• Who has the power to reject it?

Systems thinking that ignores power can become a sophisticated way to preserve existing arrangements. Systems thinking that includes power can become a tool for institutional honesty.

Back to top ↑

Wicked Problems and Contested Frames

Some problems are difficult not merely because they are technically complex, but because the problem itself is contested. These are often called wicked problems. They involve uncertainty, conflicting values, distributed responsibility, incomplete knowledge, changing conditions, and disagreement about what would count as success. Climate adaptation, homelessness, public safety, poverty, education reform, AI governance, infrastructure transition, migration, and public-health preparedness all contain wicked-problem dynamics.

Wicked problems cannot be solved by better data alone because disagreement exists at the level of framing. Different actors define the problem differently because they occupy different positions, hold different values, bear different risks, and imagine different futures. A homelessness crisis may be framed as a housing supply problem, mental-health crisis, labor-market failure, addiction issue, public-space conflict, poverty problem, policy failure, or human rights issue. Each frame has implications. None is complete by itself.

Systems thinking helps with wicked problems by making frames visible. It does not magically dissolve disagreement. Instead, it asks how different frames define boundaries, causes, stakeholders, evidence, and interventions. This can turn conflict from a hidden struggle over assumptions into an explicit inquiry into problem definition.

Wicked problems require humility because framing choices shape conclusions. They also require action because waiting for perfect agreement can become an excuse for inaction. Boundary critique helps by clarifying what is known, what is contested, who is affected, what harms are urgent, what uncertainty remains, and what adaptive learning process can accompany intervention.

The goal is not to produce a frame that ends disagreement. The goal is to produce a frame honest enough to guide responsible action under complexity.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

System boundaries and problem framing can be represented through qualitative maps, stakeholder matrices, causal-loop diagrams, scenario analysis, institutional analysis, and participatory methods. They can also be supported computationally through sensitivity analysis, network models, boundary comparison, externality accounting, and scenario modeling. The purpose of modeling is not to pretend that boundary questions are purely technical. The purpose is to make the consequences of boundary choices visible.

A basic systems model can be written as:

A boundary sensitivity analysis asks how conclusions change when the boundary changes:

Externality accounting can be represented as:

A stakeholder inclusion index can be used cautiously as a diagnostic tool:

Computational support for boundary thinking may include:

• comparing outcomes under narrow, moderate, and broad system boundaries;
• mapping which stakeholders are affected but excluded from decision-making;
• testing whether externalized costs reverse a conclusion;
• identifying variables that become visible only under expanded frames;
• modeling how risks move across administrative, ecological, or institutional boundaries;
• building scenario comparisons that include different time horizons;
• documenting assumptions behind each boundary choice.

Boundary modeling should be used with humility. Some boundary questions cannot be settled by computation alone. Values, rights, dignity, historical injustice, ecological responsibility, and democratic legitimacy require judgment. The strongest modeling practice does not hide those judgments. It documents them.

Back to top ↑

Python Workflow: Boundary Sensitivity and Frame Diagnostics

The Python workflow below turns boundary critique into a small reproducible model. It compares four frames: a narrow technical frame, an organizational frame, a socio-ecological frame, and an accountable boundary-critique frame. 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.

# boundary_sensitivity_workflow.py
# Dependency-light workflow for boundary sensitivity, stakeholder inclusion,
# externality accounting, and problem-frame diagnostics.
# Writes outputs relative to the article root.

from __future__ import annotations

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

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


@dataclass
class BoundaryFrame:
    name: str
    boundary_width: float
    stakeholder_inclusion: float
    externality_accounting: float
    time_horizon: float
    cross_scale_visibility: float
    accountability: float
    action_specificity: float
    harm_exposure: float


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


def run_frame(frame: BoundaryFrame, periods: int = 36) -> list[dict[str, object]]:
    boundary_quality = frame.boundary_width * 34.0
    externalized_harm = frame.harm_exposure * 58.0
    stakeholder_trust = 36.0 + frame.stakeholder_inclusion * 18.0
    action_capacity = frame.action_specificity * 44.0
    rows: list[dict[str, object]] = []

    for period in range(periods + 1):
        inclusion_score = clamp(
            frame.stakeholder_inclusion * 24.0
            + frame.cross_scale_visibility * 16.0
            + stakeholder_trust * 0.12
            + frame.accountability * 14.0
        )

        externality_visibility = clamp(
            frame.externality_accounting * 26.0
            + frame.boundary_width * 14.0
            + frame.time_horizon * 18.0
            + frame.cross_scale_visibility * 14.0
        )

        boundary_quality = clamp(
            boundary_quality
            + inclusion_score * 0.08
            + externality_visibility * 0.07
            + frame.accountability * 1.4
            - max(0.0, 35.0 - action_capacity) * 0.05
        )

        frame_risk = clamp(
            frame.harm_exposure * 22.0
            + max(0.0, 60.0 - externality_visibility) * 0.22
            + max(0.0, 55.0 - inclusion_score) * 0.18
            + max(0.0, 45.0 - boundary_quality) * 0.16
            - frame.accountability * 4.0
        )

        externalized_harm = clamp(
            externalized_harm
            + frame_risk * 0.20
            - externality_visibility * 0.11
            - frame.accountability * 1.6
        )

        stakeholder_trust = clamp(
            stakeholder_trust
            + inclusion_score * 0.08
            + frame.accountability * 1.8
            - externalized_harm * 0.05
        )

        action_capacity = clamp(
            action_capacity
            + frame.action_specificity * 1.8
            + frame.accountability * 1.3
            + boundary_quality * 0.04
            - max(0.0, frame.boundary_width * 100.0 - 82.0) * 0.03
        )

        boundary_critique_score = clamp(
            boundary_quality * 0.24
            + inclusion_score * 0.22
            + externality_visibility * 0.22
            + stakeholder_trust * 0.10
            + action_capacity * 0.16
            - externalized_harm * 0.16
            - frame_risk * 0.10
        )

        rows.append({
            "period": period,
            "frame": frame.name,
            "boundary_quality": round(boundary_quality, 3),
            "inclusion_score": round(inclusion_score, 3),
            "externality_visibility": round(externality_visibility, 3),
            "frame_risk": round(frame_risk, 3),
            "externalized_harm": round(externalized_harm, 3),
            "stakeholder_trust": round(stakeholder_trust, 3),
            "action_capacity": round(action_capacity, 3),
            "boundary_critique_score": round(boundary_critique_score, 3),
        })

    return rows


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 summarize(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    output: list[dict[str, object]] = []
    for frame_name in sorted({row["frame"] for row in rows}):
        subset = [row for row in rows if row["frame"] == frame_name]
        final = subset[-1]
        avg_risk = mean(float(row["frame_risk"]) for row in subset)
        avg_harm = mean(float(row["externalized_harm"]) for row in subset)
        avg_score = mean(float(row["boundary_critique_score"]) for row in subset)

        if float(final["boundary_critique_score"]) >= 65 and float(final["externalized_harm"]) <= 35:
            diagnostic = "usable boundary with strong critique and accountable action"
        elif avg_harm >= 55:
            diagnostic = "boundary hides externalized harm"
        elif avg_risk >= 50:
            diagnostic = "frame risk remains high; revise boundary assumptions"
        elif avg_score >= 55:
            diagnostic = "partial boundary critique with remaining blind spots"
        else:
            diagnostic = "weak framing discipline"

        output.append({
            "frame": frame_name,
            "final_boundary_critique_score": final["boundary_critique_score"],
            "final_externalized_harm": final["externalized_harm"],
            "final_frame_risk": final["frame_risk"],
            "final_action_capacity": final["action_capacity"],
            "final_stakeholder_trust": final["stakeholder_trust"],
            "average_frame_risk": round(avg_risk, 3),
            "average_externalized_harm": round(avg_harm, 3),
            "average_boundary_critique_score": round(avg_score, 3),
            "diagnostic": diagnostic,
        })

    return output


def main() -> None:
    frames = [
        BoundaryFrame("Narrow technical frame", 0.28, 0.20, 0.18, 0.22, 0.24, 0.22, 0.72, 0.74),
        BoundaryFrame("Organizational frame", 0.46, 0.42, 0.36, 0.38, 0.44, 0.42, 0.66, 0.60),
        BoundaryFrame("Socio-ecological frame", 0.76, 0.66, 0.72, 0.78, 0.72, 0.62, 0.58, 0.42),
        BoundaryFrame("Accountable boundary critique", 0.72, 0.82, 0.84, 0.80, 0.78, 0.80, 0.76, 0.30),
    ]

    rows: list[dict[str, object]] = []
    for frame in frames:
        rows.extend(run_frame(frame))

    write_csv(TABLES / "boundary_sensitivity_timeseries.csv", rows)
    write_csv(TABLES / "boundary_sensitivity_summary.csv", summarize(rows))

    print("Boundary sensitivity workflow complete.")
    print(TABLES / "boundary_sensitivity_timeseries.csv")


if __name__ == "__main__":
    main()

The workflow is intentionally simple enough to inspect. It shows how a narrow frame can preserve action specificity while hiding externalized harm, and how a broader frame becomes useful only when joined to stakeholder inclusion, externality accounting, accountability, and enough specificity to guide action. The model is synthetic and illustrative; it supports disciplined inquiry rather than replacing domain expertise, affected-community knowledge, or ethical judgment.

Back to top ↑

R Workflow: Boundary Comparison and Scenario Visualization

The R workflow reads the Python-generated time-series output, creates boundary-comparison summaries, and exports base R plots for boundary quality, stakeholder inclusion, externality visibility, frame risk, externalized harm, and boundary-critique score. It uses only base R so it remains portable across simple local environments.

# boundary_sensitivity_diagnostics.R
# Base R workflow for boundary comparison and scenario 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, "boundary_sensitivity_timeseries.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_frame <- do.call(
  rbind,
  lapply(split(data, data$frame), function(df) df[nrow(df), ])
)

avg_risk <- aggregate(frame_risk ~ frame, data = data, FUN = mean)
avg_harm <- aggregate(externalized_harm ~ frame, data = data, FUN = mean)
avg_score <- aggregate(boundary_critique_score ~ frame, data = data, FUN = mean)

names(avg_risk)[2] <- "average_frame_risk"
names(avg_harm)[2] <- "average_externalized_harm"
names(avg_score)[2] <- "average_boundary_critique_score"

final_fields <- last_by_frame[, c(
  "frame",
  "boundary_critique_score",
  "externalized_harm",
  "frame_risk",
  "action_capacity",
  "stakeholder_trust"
)]

names(final_fields) <- c(
  "frame",
  "final_boundary_critique_score",
  "final_externalized_harm",
  "final_frame_risk",
  "final_action_capacity",
  "final_stakeholder_trust"
)

summary_table <- Reduce(
  function(x, y) merge(x, y, by = "frame"),
  list(avg_risk, avg_harm, avg_score, final_fields)
)

summary_table$diagnostic <- ifelse(
  summary_table$final_boundary_critique_score >= 65 &
    summary_table$final_externalized_harm <= 35,
  "usable boundary with strong critique and accountable action",
  ifelse(
    summary_table$average_externalized_harm >= 55,
    "boundary hides externalized harm",
    ifelse(
      summary_table$average_frame_risk >= 50,
      "frame risk remains high; revise boundary assumptions",
      ifelse(
        summary_table$average_boundary_critique_score >= 55,
        "partial boundary critique with remaining blind spots",
        "weak framing discipline"
      )
    )
  )
)

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

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

plot_metric("boundary_quality", "Boundary quality", "boundary_quality_trajectories.png")
plot_metric("inclusion_score", "Inclusion score", "inclusion_score_trajectories.png")
plot_metric("externality_visibility", "Externality visibility", "externality_visibility_trajectories.png")
plot_metric("frame_risk", "Frame risk", "frame_risk_trajectories.png")
plot_metric("externalized_harm", "Externalized harm", "externalized_harm_trajectories.png")
plot_metric("boundary_critique_score", "Boundary critique score", "boundary_critique_score_trajectories.png")

print(summary_table)

This workflow supports the article’s central methodological claim: a system boundary should be tested, not assumed. The R outputs help readers see how conclusions change when problem frames widen, include affected stakeholders, account for externalities, and build accountability into the analysis.

Back to top ↑

GitHub Repository

The companion repository for this article should help readers examine how system boundaries and problem frames change analysis. It should include synthetic datasets, stakeholder matrices, boundary-comparison workflows, externality accounting examples, cross-scale scenario analysis, causal maps, and documentation that makes boundary assumptions explicit.

articles/system-boundaries-and-problem-framing/
├── python/
│   ├── boundary_sensitivity_workflow.py
│   ├── boundary_sensitivity_analysis.py
│   ├── problem_frame_comparison.py
│   ├── stakeholder_inclusion_diagnostics.py
│   ├── externality_accounting.py
│   ├── cross_scale_scenario_analysis.py
│   ├── boundary_causal_map.py
│   ├── validation_checks.py
│   └── run_all_boundary_workflows.py
├── r/
│   ├── boundary_sensitivity_diagnostics.R
│   ├── boundary_comparison_tables.R
│   ├── stakeholder_matrix_visualization.R
│   ├── externality_scenario_plots.R
│   ├── cross_scale_indicators.R
│   ├── problem_frame_summary.R
│   └── run_all_boundary_workflows.R
├── julia/
│   ├── dynamic_boundary_examples.jl
│   └── nonlinear_frame_sensitivity.jl
├── sql/
│   ├── schema_system_boundaries.sql
│   ├── schema_problem_frames.sql
│   ├── schema_stakeholders.sql
│   ├── schema_externalities.sql
│   ├── schema_scenarios.sql
│   ├── schema_indicators.sql
│   └── schema_model_runs.sql
├── rust/
│   └── boundary_diagnostics_cli.rs
├── go/
│   └── frame_pathway_utility.go
├── cpp/
│   ├── efficient_boundary_network.cpp
│   └── frame_sensitivity_example.cpp
├── fortran/
│   └── recurrence_boundary_model.f90
├── c/
│   └── low_level_boundary_simulation.c
├── docs/
│   ├── modeling_principles.md
│   ├── article_notes.md
│   ├── assumptions_and_limitations.md
│   └── responsible_use.md
├── data/
│   ├── synthetic_boundaries.csv
│   ├── synthetic_problem_frames.csv
│   ├── synthetic_stakeholders.csv
│   ├── synthetic_externalities.csv
│   ├── synthetic_scenarios.csv
│   └── synthetic_indicators.csv
├── outputs/
│   ├── figures/
│   └── tables/
└── notebooks/
    ├── python_boundary_critique_walkthrough.ipynb
    └── r_frame_comparison_placeholder.ipynb

This repository structure supports the article’s central argument: boundaries and frames change what a system analysis can see. The data/ folder separates system boundaries, problem frames, stakeholders, externalities, scenarios, and indicators. The python/ and r/ folders support boundary sensitivity, stakeholder inclusion, externality accounting, cross-scale comparison, and problem-frame summaries. The julia/ folder supports dynamic and nonlinear frame-sensitivity examples. The sql/ folder provides schemas for boundaries, frames, stakeholders, externalities, indicators, scenarios, and model runs. The lower-level language folders provide scaffolds for diagnostics, efficient boundary-network analysis, recurrence, and simulation.

Back to top ↑

Back to top ↑

Back to top ↑

Why Boundary Thinking Matters

System boundaries and problem framing determine what systems thinking becomes. A boundary can reveal structure or hide it. A frame can expand accountability or narrow it. A time horizon can expose accumulation or erase it. A stakeholder definition can include lived knowledge or silence it. A cost boundary can reveal externalization or protect it.

This is why systems thinking must begin with humility about its own frame. No analysis sees everything. No model includes the whole world. No boundary is innocent. The discipline lies in making boundary choices explicit, testing them against alternative frames, and asking what consequences follow from drawing the system one way rather than another.

Boundary thinking is especially important for sustainability, governance, infrastructure, public health, technology, organizational design, and institutional reform because the deepest harms often live outside the official frame. Costs are shifted, risks are displaced, histories are ignored, stakeholders are excluded, and success is declared inside boundaries too narrow to be truthful.

To practice systems thinking responsibly is to ask not only “What is the system?” but “Who drew this boundary, what does it reveal, what does it conceal, and what would become visible if the system were framed differently?”

Back to top ↑

Related Articles

• What Is Systems Thinking?
• Patterns, Events, and Structural Explanation
• Wholes, Parts, and Interdependence
• Causality in Systems Thinking
• Systems Thinking and Levels of Analysis
• Feedback Loops and System Behavior
• Behavior Over Time and Structural Explanation
• Dynamic Complexity and Policy Resistance

Further Reading

• Churchman, C. West. The Systems Approach. Delacorte Press.
• Ulrich, Werner. Critical Heuristics of Social Planning: A New Approach to Practical Philosophy. Haupt.
• Midgley, Gerald. Systemic Intervention: Philosophy, Methodology, and Practice. Springer.
• Checkland, Peter. Systems Thinking, Systems Practice. John Wiley & Sons.
• Rittel, Horst W.J. and Webber, Melvin M. “Dilemmas in a General Theory of Planning.” Policy Sciences.
• Meadows, Donella H. Thinking in Systems: A Primer. Chelsea Green Publishing.
• Sterman, John D. Business Dynamics: Systems Thinking and Modeling for a Complex World. Irwin/McGraw-Hill.

Back to top ↑

References

• Checkland, P. (1981) Systems Thinking, Systems Practice. Chichester: John Wiley & Sons.
• Churchman, C.W. (1968) The Systems Approach. New York: Delacorte Press.
• 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/
• Midgley, G. (2000) Systemic Intervention: Philosophy, Methodology, and Practice. New York: Springer.
• Rittel, H.W.J. and Webber, M.M. (1973) “Dilemmas in a General Theory of Planning.” Policy Sciences, 4, pp. 155–169.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.
• Ulrich, W. (1983) Critical Heuristics of Social Planning: A New Approach to Practical Philosophy. Bern: Haupt.

Back to top ↑