What Is Decision Science?

Last Updated June 5, 2026

Decision science is the interdisciplinary study of how choices are structured, evaluated, and made under conditions of uncertainty, complexity, and competing objectives. It integrates formal analytical methods from economics, statistics, operations research, systems modeling, applied mathematics, and computer science with empirical insights from psychology, organizational behavior, governance, and behavioral research.

What Is Decision Science? introduces decision science as a practical discipline for improving judgment when knowledge is incomplete, outcomes are uncertain, values conflict, and consequences unfold over time. It explains why decision science is broader than decision theory, why decision quality is not the same as outcome quality, why uncertainty changes the nature of choice, and why better decisions require explicit alternatives, evidence, criteria, assumptions, trade-offs, accountability, and learning.

This article explains decision science as a field of structured judgment. It examines decision framing, alternatives, objectives, probability, uncertainty, risk, utility, evidence, behavioral bias, organizational decision-making, systems complexity, robust decision-making, and accountable decision records. It also introduces a mathematical lens for expected value, expected utility, regret, multi-criteria scoring, sensitivity analysis, robustness, and the value of information. The computational sections provide professional Python and R workflows for decision diagnostics, scenario comparison, trade-off analysis, reproducible summaries, and decision-record support.

Why Decision Science Matters

Decision science matters because consequential choices are rarely made under conditions of certainty, clarity, or consensus. Public agencies allocate resources before all evidence is known. Healthcare professionals make diagnostic and treatment decisions under uncertainty. Financial institutions manage portfolios exposed to rare events and systemic risk. Infrastructure planners invest in assets that must remain useful for decades. Organizations choose strategies while competitors, technologies, regulations, and markets change. Climate, security, public health, AI governance, and sustainability decisions unfold across systems that are uncertain, contested, and adaptive.

In these settings, intuition alone is not enough. Intuition may be useful, fast, and experience-based, but it can also be distorted by availability, anchoring, confirmation bias, overconfidence, framing, group pressure, incentives, and institutional habit. Formal modeling alone is also not enough. A model can be mathematically precise while the decision is poorly framed, the alternatives are too narrow, the values are hidden, the evidence is weak, or the assumptions are fragile.

Decision science occupies the space between informal intuition and narrow optimization. It helps decision-makers define the decision, identify alternatives, clarify objectives, represent uncertainty, evaluate evidence, surface trade-offs, test assumptions, compare options, document rationale, and learn from outcomes. Its purpose is not to remove judgment. Its purpose is to make judgment more disciplined, transparent, testable, and accountable.

Decision science is therefore not only a technical field. It is a discipline of responsible reasoning. It connects analysis to judgment, judgment to accountability, and accountability to learning.

Back to top ↑

What Decision Science Studies

Decision science studies how decisions are structured, evaluated, made, implemented, and revised. It asks how people and institutions should reason when they face uncertainty, incomplete evidence, competing values, limited time, limited attention, and consequences that may unfold across long time horizons. The field includes formal models, behavioral insights, organizational analysis, computational workflows, and governance practices.

At a practical level, decision science studies the relationship between a decision frame, a set of alternatives, uncertain states of the world, possible outcomes, preferences or values, evidence, criteria, decision rules, and post-decision learning. A decision is not simply a moment of choice. It is a process that begins with framing and continues through implementation, monitoring, revision, and accountability.

Decision science also studies failure. Decisions may fail because alternatives were too narrow, probabilities were overconfident, incentives distorted judgment, dissent was suppressed, values were hidden, short-term metrics overwhelmed long-term consequences, or models were treated as substitutes for responsibility. A decision-science approach tries to identify these failure modes before they become institutional damage.

Decision science is strongest when these elements are treated as connected. A probability model without a clear decision frame is not enough. A multi-criteria score without transparent weights is not enough. A forecast without sensitivity analysis is not enough. A recommendation without a decision record is not enough.

Back to top ↑

Decision Science vs. Decision Theory

Decision theory is a formal field concerned with rational choice, preferences, probability, utility, and decision rules. It asks how an idealized decision-maker should choose if preferences are coherent and uncertainty can be represented formally. Decision theory provides important foundations for expected utility, Bayesian decision-making, risk attitudes, and rational-choice models.

Decision science includes decision theory, but it is broader and more applied. It asks how decisions are framed, modeled, discussed, governed, implemented, documented, and learned from in real settings. It is concerned not only with formal rationality, but also with bounded rationality, behavioral bias, organizational incentives, stakeholder values, model uncertainty, public legitimacy, and accountability.

The distinction matters because real decisions often fail before formal analysis begins. The wrong problem may be framed. Alternatives may be too narrow. Values may be hidden. Probabilities may be invented without evidence. A model may optimize the wrong objective. Decision science treats these upstream issues as central, not peripheral.

Back to top ↑

Decision Quality: Process, Not Outcome Guarantee

A central idea in decision science is that decision quality is not the same as outcome quality. A good decision can lead to a bad outcome when uncertainty resolves unfavorably. A poor decision can lead to a good outcome through luck. Without this distinction, organizations and individuals often confuse results with reasoning.

Decision quality concerns the process by which a decision is made. Was the decision clearly defined? Were meaningful alternatives considered? Were objectives explicit? Were uncertainties represented honestly? Was relevant evidence examined? Were trade-offs surfaced? Were assumptions tested? Were stakeholders and consequences considered? Was the rationale documented? Were conditions for review or revision identified?

This distinction is especially important in high-uncertainty environments. If decision-makers judge every process only by the outcome that happened to occur, they may punish sound reasoning and reward lucky mistakes. Decision science therefore supports both better decisions and better learning. It allows a decision record to be evaluated after the fact without pretending that hindsight was available at the time.

Back to top ↑

Framing the Decision

Every decision model rests on a prior act of framing. Before alternatives can be scored, probabilities estimated, utilities calculated, or scenarios compared, someone must define what decision is being made. This is often more difficult than it appears.

A poorly framed decision may ask whether to approve a single proposal rather than asking which alternatives could satisfy the underlying objective. It may treat a symptom as the problem. It may define the time horizon too narrowly. It may ignore affected stakeholders. It may treat uncertainty as noise rather than as a central feature of the decision environment. It may ask for optimization when the real challenge is robustness, legitimacy, learning, or adaptation.

Decision framing clarifies the unit of choice. Is the decision about selecting an option, designing a portfolio, choosing a sequence, establishing a policy, delaying action, gathering more information, or creating adaptive pathways? Each framing leads to different analytical methods and different responsibilities.

Professional decision science begins with this framing discipline. Modeling should support the decision that actually needs to be made, not create a technical substitute for defining it.

Back to top ↑

Alternatives, Objectives, and Criteria

Decision quality depends heavily on the quality of alternatives. Many weak decisions are not caused by poor scoring methods but by narrow option generation. If the alternatives are poorly designed, no amount of calculation can produce a strong decision.

Decision science therefore treats alternatives as objects of analysis, not merely inputs into a model. Alternatives may be mutually exclusive choices, staged pathways, portfolios, policies, investments, experiments, safeguards, or hybrid strategies. In complex systems, the best alternative is often not a single fixed plan but an adaptive sequence with monitoring points and revision triggers.

Objectives are equally important. A decision that appears technical may actually involve multiple objectives: cost, reliability, equity, safety, resilience, legitimacy, speed, reversibility, learning, public trust, environmental impact, and long-term adaptability. Multi-objective decisions require explicit structure because hidden weighting can distort judgment.

Choice architecture refers to the way options are presented, compared, sequenced, and constrained. A decision process can bias outcomes by making one alternative appear default, by excluding slower but safer options, by emphasizing easily measured benefits, or by hiding distributional consequences. Decision science makes this architecture visible so judgment can be examined rather than smuggled into the process.

Back to top ↑

Uncertainty, Risk, and Evidence

Uncertainty is the central condition under which decision science operates. In simple settings, the decision-maker may know the alternatives, outcomes, and probabilities. In consequential settings, those elements are often incomplete, contested, unstable, or only partially measurable.

Decision science distinguishes among several forms of uncertainty. Risk refers to situations where outcomes are uncertain but probabilities can be estimated with some confidence. Statistical uncertainty concerns limited data, sampling variation, measurement error, or model estimation. Model uncertainty arises when multiple plausible models could explain or forecast the situation. Deep uncertainty occurs when decision-makers cannot confidently agree on probabilities, models, outcomes, values, or system boundaries.

Different uncertainty conditions require different decision methods. Expected value may be useful when probabilities and outcomes are credible. Bayesian updating may be useful when evidence arrives over time. Sensitivity analysis may be useful when conclusions depend on contested assumptions. Scenario analysis may be useful when the future cannot be reduced to a single forecast. Robust decision-making may be useful when the goal is to identify strategies that perform acceptably across many plausible futures.

Evidence is not merely data. Evidence includes measurements, studies, expert judgment, historical cases, simulations, stakeholder knowledge, uncertainty ranges, assumptions, and observed feedback. Decision science asks not only what the evidence says, but how reliable, relevant, current, biased, transferable, and decision-sensitive that evidence is.

Back to top ↑

Values, Utility, and Trade-Offs

Most important decisions involve trade-offs. Objectives conflict. Resources are limited. Stakeholders value outcomes differently. Benefits and burdens are distributed unevenly. Some consequences are measurable, while others are qualitative, ethical, political, or long-term.

Decision science does not remove value judgment. It makes value judgment more visible. A model that assigns weights to criteria is not value-free. A cost-benefit analysis that monetizes outcomes embeds assumptions about comparability. A risk model that prioritizes average loss may understate distributional harm. A strategy that maximizes efficiency may weaken resilience. A policy that improves aggregate outcomes may impose unacceptable burdens on specific groups.

Utility is one way to represent preference, but utility should not be confused with moral truth. A utility function can help clarify risk attitude, diminishing marginal value, and preference structure. It cannot decide whose values count, whether trade-offs are legitimate, or whether a distribution of harm is acceptable. Those questions require governance, ethics, participation, and accountability.

The goal is not to turn values into arithmetic and then pretend the arithmetic has resolved the ethical question. The goal is to prevent values from remaining hidden.

Back to top ↑

Behavioral Judgment and Bias

Decision science is not only a formal field. It is also a behavioral field. People do not make decisions as perfectly rational agents with unlimited attention and flawless probability judgment. They use heuristics, rely on memory, interpret information through frames, respond to incentives, defer to authority, conform to groups, protect identity, and simplify complexity.

Heuristics can be useful. They allow fast action under pressure and can encode experience. But they can also create predictable errors. Availability bias can cause recent or vivid events to dominate judgment. Anchoring can cause initial numbers to shape later estimates. Confirmation bias can lead decision-makers to seek evidence that supports existing beliefs. Loss aversion can make losses feel more significant than equivalent gains. Overconfidence can narrow uncertainty ranges and suppress dissent.

Decision science responds to these limitations by improving process design. It encourages pre-mortems, independent estimates, structured dissent, reference class forecasting, calibration training, explicit uncertainty ranges, decision records, red-team review, and post-decision learning. The goal is not to eliminate human judgment. The goal is to create conditions under which judgment becomes less distorted and more accountable.

Back to top ↑

Organizations, Governance, and Accountability

Many consequential decisions are made by organizations rather than isolated individuals. This changes the problem. Organizations have hierarchies, incentives, routines, budgets, cultures, political constraints, reporting structures, and informal norms. A technically sound analysis can fail if the organization lacks the capacity, authority, trust, or incentive structure to act on it.

Decision science therefore includes decision governance. Governance asks who has authority, who provides evidence, who reviews assumptions, who represents affected interests, who documents the rationale, who monitors outcomes, and who revises the decision when conditions change. It also asks how dissent is handled and whether decision processes reward accuracy, learning, and accountability rather than confidence, speed, or political convenience.

Decision records are especially important. A decision record documents the decision being made, alternatives considered, criteria used, evidence reviewed, assumptions made, uncertainties identified, rationale chosen, implementation responsibilities, monitoring indicators, and review triggers. This allows later evaluation to distinguish unforeseeable uncertainty from avoidable process failure.

Without documentation, organizations often learn the wrong lesson. They remember the outcome, forget the assumptions, and reconstruct the rationale after the fact. Decision science helps preserve the reasoning context so institutional learning becomes possible.

Back to top ↑

Complex Systems and Robustness

Many decisions are embedded in complex systems characterized by interdependence, adaptation, feedback, delay, nonlinear effects, and emergent behavior. In such systems, interventions can produce unintended consequences long after the original decision appears to have succeeded.

A policy that improves one variable in the short term may create larger systemic costs later. A local optimization may undermine system-level resilience. A strategy that appears efficient under current assumptions may fail when the environment changes. A risk control that reduces one hazard may shift vulnerability elsewhere. A technology that improves productivity may reshape incentives, labor, governance, and public trust.

Robustness becomes central in these environments. A robust decision is not necessarily the option that performs best under one forecast. It is an option, portfolio, or pathway that performs acceptably across a wide range of plausible futures. Under deep uncertainty, the question shifts from “What is optimal?” to “What remains viable if the world does not behave as expected?”

This systems perspective is especially important for climate adaptation, infrastructure planning, public health, financial risk, AI governance, supply chains, crisis management, and sustainability transitions. In these domains, the decision environment changes while the decision is being implemented.

Back to top ↑

Back to top ↑

Mathematical Lens: Expected Value, Utility, Regret, and Robustness

The mathematical lens of decision science helps make uncertainty, value, trade-offs, and robustness explicit. These formulas do not replace judgment. They clarify what the judgment depends on.

Expected value evaluates an alternative by weighting outcomes by their probabilities:

Expected utility extends expected value by applying a utility function to outcomes:

Regret analysis compares each alternative with the best alternative that would have been chosen if a particular state of the world had been known in advance:

A minimax regret rule selects the alternative with the smallest worst-case regret:

Multi-criteria decision analysis evaluates alternatives across criteria using normalized scores and weights:

Robustness evaluates how often an alternative meets an acceptability threshold across scenarios:

The mathematical lens makes decision reasoning inspectable. It shows where the recommendation comes from, which assumptions matter, and whether the preferred option is stable or fragile.

Back to top ↑

Python Workflow: Expected Value, Regret, Robustness, and Scenario Diagnostics

The Python workflow below creates a reproducible decision-science diagnostic model. It evaluates alternatives across uncertain scenarios, computes expected value, expected utility, minimax regret, maximin performance, robustness thresholds, MCDA scores, sensitivity diagnostics, and a machine-readable decision record. The script uses only the Python standard library and writes CSV and JSON outputs relative to the article folder.

# decision_science_diagnostics_workflow.py
# Standard-library decision-science workflow:
# expected value, expected utility, regret, robustness, MCDA, sensitivity,
# and decision-record export for professional decision analysis scaffolding.

from __future__ import annotations

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

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


@dataclass(frozen=True)
class Scenario:
    name: str
    probability: float
    demand_multiplier: float
    cost_pressure: float
    implementation_risk: float
    disruption_level: float


@dataclass(frozen=True)
class Alternative:
    name: str
    base_benefit: float
    base_cost: float
    flexibility: float
    resilience: float
    implementation_capacity: float
    equity_score: float
    evidence_quality: float
    reversibility: float


@dataclass(frozen=True)
class Criterion:
    name: str
    weight: float
    direction: str


def utility(value: float, risk_aversion: float = 0.018) -> float:
    """Exponential utility for monetary or value-index outcomes."""
    return 1.0 - math.exp(-risk_aversion * value)


def scenario_outcome(alternative: Alternative, scenario: Scenario) -> float:
    benefit = alternative.base_benefit * scenario.demand_multiplier
    direct_cost = alternative.base_cost * scenario.cost_pressure
    implementation_penalty = scenario.implementation_risk * (1.0 - alternative.implementation_capacity) * 35.0
    disruption_penalty = scenario.disruption_level * (1.0 - alternative.resilience) * 45.0
    flexibility_credit = alternative.flexibility * scenario.disruption_level * 18.0
    evidence_penalty = (1.0 - alternative.evidence_quality) * 12.0
    return benefit - direct_cost - implementation_penalty - disruption_penalty + flexibility_credit - evidence_penalty


def normalize(values: dict[str, float], direction: str) -> dict[str, float]:
    low = min(values.values())
    high = max(values.values())
    if math.isclose(high, low):
        return {key: 1.0 for key in values}
    if direction == "benefit":
        return {key: (value - low) / (high - low) for key, value in values.items()}
    return {key: (high - value) / (high - low) for key, value in values.items()}


def expected_value(alternative: Alternative, scenarios: list[Scenario]) -> float:
    return sum(s.probability * scenario_outcome(alternative, s) for s in scenarios)


def expected_utility(alternative: Alternative, scenarios: list[Scenario]) -> float:
    return sum(s.probability * utility(scenario_outcome(alternative, s)) for s in scenarios)


def outcome_matrix(alternatives: list[Alternative], scenarios: list[Scenario]) -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []
    for alternative in alternatives:
        for scenario in scenarios:
            rows.append({
                "alternative": alternative.name,
                "scenario": scenario.name,
                "probability": round(scenario.probability, 4),
                "outcome_value": round(scenario_outcome(alternative, scenario), 4),
            })
    return rows


def regret_matrix(alternatives: list[Alternative], scenarios: list[Scenario]) -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []
    for scenario in scenarios:
        outcomes = {
            alternative.name: scenario_outcome(alternative, scenario)
            for alternative in alternatives
        }
        best_outcome = max(outcomes.values())
        for alternative_name, value in outcomes.items():
            rows.append({
                "alternative": alternative_name,
                "scenario": scenario.name,
                "best_scenario_outcome": round(best_outcome, 4),
                "outcome_value": round(value, 4),
                "regret": round(best_outcome - value, 4),
            })
    return rows


def mcda_scores(alternatives: list[Alternative], criteria: list[Criterion]) -> list[dict[str, object]]:
    raw: dict[str, dict[str, float]] = {
        alternative.name: {
            "net_benefit": alternative.base_benefit - alternative.base_cost,
            "flexibility": alternative.flexibility,
            "resilience": alternative.resilience,
            "implementation_capacity": alternative.implementation_capacity,
            "equity_score": alternative.equity_score,
            "evidence_quality": alternative.evidence_quality,
            "reversibility": alternative.reversibility,
        }
        for alternative in alternatives
    }

    normalized_by_criterion: dict[str, dict[str, float]] = {}
    for criterion in criteria:
        values = {name: metrics[criterion.name] for name, metrics in raw.items()}
        normalized_by_criterion[criterion.name] = normalize(values, criterion.direction)

    rows: list[dict[str, object]] = []
    for alternative in alternatives:
        score = 0.0
        for criterion in criteria:
            score += criterion.weight * normalized_by_criterion[criterion.name][alternative.name]
        rows.append({
            "alternative": alternative.name,
            "mcda_score": round(score, 4),
            "net_benefit": round(raw[alternative.name]["net_benefit"], 4),
            "flexibility": alternative.flexibility,
            "resilience": alternative.resilience,
            "implementation_capacity": alternative.implementation_capacity,
            "equity_score": alternative.equity_score,
            "evidence_quality": alternative.evidence_quality,
            "reversibility": alternative.reversibility,
        })
    return sorted(rows, key=lambda row: float(row["mcda_score"]), reverse=True)


def summarize_decisions(alternatives: list[Alternative], scenarios: list[Scenario], criteria: list[Criterion]) -> list[dict[str, object]]:
    regrets = regret_matrix(alternatives, scenarios)
    mcda = {row["alternative"]: row for row in mcda_scores(alternatives, criteria)}
    rows: list[dict[str, object]] = []

    for alternative in alternatives:
        outcomes = [scenario_outcome(alternative, scenario) for scenario in scenarios]
        alternative_regrets = [
            float(row["regret"])
            for row in regrets
            if row["alternative"] == alternative.name
        ]
        robustness_threshold = 35.0
        rows.append({
            "alternative": alternative.name,
            "expected_value": round(expected_value(alternative, scenarios), 4),
            "expected_utility": round(expected_utility(alternative, scenarios), 6),
            "minimum_outcome": round(min(outcomes), 4),
            "maximum_outcome": round(max(outcomes), 4),
            "average_outcome": round(mean(outcomes), 4),
            "maximum_regret": round(max(alternative_regrets), 4),
            "average_regret": round(mean(alternative_regrets), 4),
            "robustness_share": round(
                sum(1 for outcome in outcomes if outcome >= robustness_threshold) / len(outcomes),
                4,
            ),
            "mcda_score": mcda[alternative.name]["mcda_score"],
            "evidence_quality": alternative.evidence_quality,
            "decision_note": classify_decision_profile(
                expected_value(alternative, scenarios),
                max(alternative_regrets),
                sum(1 for outcome in outcomes if outcome >= robustness_threshold) / len(outcomes),
                float(mcda[alternative.name]["mcda_score"]),
            ),
        })

    return sorted(
        rows,
        key=lambda row: (
            float(row["robustness_share"]),
            float(row["expected_value"]),
            -float(row["maximum_regret"]),
            float(row["mcda_score"]),
        ),
        reverse=True,
    )


def classify_decision_profile(expected: float, max_regret: float, robustness: float, mcda: float) -> str:
    if robustness >= 0.75 and expected >= 40.0 and max_regret <= 25.0:
        return "strong robust candidate"
    if expected >= 45.0 and max_regret > 35.0:
        return "high expected value but regret-sensitive"
    if robustness >= 0.75 and expected < 40.0:
        return "robust but moderate expected value"
    if mcda >= 0.70:
        return "strong multi-criteria profile"
    return "requires further evidence or redesign"


def sensitivity_analysis(alternatives: list[Alternative], scenarios: list[Scenario], criteria: list[Criterion]) -> list[dict[str, object]]:
    base = summarize_decisions(alternatives, scenarios, criteria)
    base_top = base[0]["alternative"]
    rows: list[dict[str, object]] = []

    for criterion in criteria:
        for delta in [-0.10, 0.10]:
            revised: list[Criterion] = []
            for item in criteria:
                new_weight = item.weight + delta if item.name == criterion.name else item.weight
                revised.append(Criterion(item.name, max(0.01, new_weight), item.direction))

            total_weight = sum(item.weight for item in revised)
            revised = [
                Criterion(item.name, item.weight / total_weight, item.direction)
                for item in revised
            ]

            revised_summary = summarize_decisions(alternatives, scenarios, revised)
            revised_top = revised_summary[0]["alternative"]
            rows.append({
                "changed_criterion": criterion.name,
                "delta": delta,
                "base_top_alternative": base_top,
                "revised_top_alternative": revised_top,
                "ranking_changed": base_top != revised_top,
                "top_expected_value": revised_summary[0]["expected_value"],
                "top_maximum_regret": revised_summary[0]["maximum_regret"],
                "top_robustness_share": revised_summary[0]["robustness_share"],
                "top_mcda_score": revised_summary[0]["mcda_score"],
            })

    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 write_decision_record(path: Path, summary: list[dict[str, object]], criteria: list[Criterion]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    record = {
        "decision": "Illustrative strategic resource-allocation decision under uncertainty",
        "selected_alternative": summary[0]["alternative"],
        "rationale": summary[0]["decision_note"],
        "modeling_principles": [
            "Define the decision before modeling options.",
            "Distinguish outcome quality from decision-process quality.",
            "Make alternatives explicit.",
            "Represent uncertainty honestly.",
            "Surface values and trade-offs.",
            "Use sensitivity analysis to test assumption dependence.",
            "Prefer robustness over fragile optimization under deep uncertainty.",
            "Document decision records for accountability and learning.",
            "Treat computational models as supports for judgment, not replacements for responsibility.",
        ],
        "criteria": [
            {"name": criterion.name, "weight": criterion.weight, "direction": criterion.direction}
            for criterion in criteria
        ],
        "summary": summary,
        "review_triggers": [
            "probability assumptions materially change",
            "maximum regret exceeds tolerance",
            "implementation capacity drops below threshold",
            "stakeholder legitimacy concerns emerge",
            "new evidence changes expected value or robustness ranking",
        ],
    }
    path.write_text(json.dumps(record, indent=2), encoding="utf-8")


def main() -> None:
    scenarios = [
        Scenario("Stable baseline", 0.30, 1.00, 1.00, 0.20, 0.10),
        Scenario("Cost pressure", 0.25, 0.92, 1.22, 0.35, 0.20),
        Scenario("High demand", 0.20, 1.28, 1.08, 0.25, 0.25),
        Scenario("System disruption", 0.15, 0.85, 1.18, 0.55, 0.70),
        Scenario("Rapid transition", 0.10, 1.12, 0.96, 0.30, 0.35),
    ]

    alternatives = [
        Alternative("Incremental improvement", 82.0, 38.0, 0.35, 0.45, 0.82, 0.58, 0.88, 0.70),
        Alternative("Robust adaptive pathway", 94.0, 52.0, 0.82, 0.88, 0.70, 0.78, 0.76, 0.84),
        Alternative("High-upside optimization", 112.0, 64.0, 0.45, 0.38, 0.62, 0.52, 0.64, 0.40),
        Alternative("Evidence-first staged pilot", 76.0, 34.0, 0.72, 0.66, 0.86, 0.74, 0.92, 0.90),
    ]

    criteria = [
        Criterion("net_benefit", 0.24, "benefit"),
        Criterion("flexibility", 0.16, "benefit"),
        Criterion("resilience", 0.18, "benefit"),
        Criterion("implementation_capacity", 0.14, "benefit"),
        Criterion("equity_score", 0.12, "benefit"),
        Criterion("evidence_quality", 0.10, "benefit"),
        Criterion("reversibility", 0.06, "benefit"),
    ]

    matrix = outcome_matrix(alternatives, scenarios)
    regrets = regret_matrix(alternatives, scenarios)
    mcda = mcda_scores(alternatives, criteria)
    summary = summarize_decisions(alternatives, scenarios, criteria)
    sensitivity = sensitivity_analysis(alternatives, scenarios, criteria)

    write_csv(TABLES / "decision_outcome_matrix.csv", matrix)
    write_csv(TABLES / "decision_regret_matrix.csv", regrets)
    write_csv(TABLES / "decision_mcda_scores.csv", mcda)
    write_csv(TABLES / "decision_summary.csv", summary)
    write_csv(TABLES / "decision_sensitivity_analysis.csv", sensitivity)
    write_decision_record(RECORDS / "decision_record.json", summary, criteria)

    print("Decision science workflow complete.")
    print(TABLES / "decision_summary.csv")
    print(RECORDS / "decision_record.json")


if __name__ == "__main__":
    main()

The workflow is designed to support professional decision-science reasoning rather than toy scoring. It separates alternatives, scenarios, criteria, assumptions, outcome modeling, regret analysis, robustness, sensitivity, and decision-record documentation. It also makes clear that a model recommendation depends on the quality of the frame, the plausibility of scenarios, the defensibility of criteria weights, and the decision-maker’s tolerance for regret and fragility.

Back to top ↑

R Workflow: MCDA, Sensitivity Profiles, and Decision Summary Reporting

The R workflow reads the Python-generated decision outputs, produces reproducible summaries, identifies ranking instability, exports base R visualizations, and creates a compact decision diagnostics report. It uses only base R so it remains portable across simple local environments.

# decision_science_summary_reporting.R
# Base R workflow for decision science diagnostics:
# MCDA summaries, regret profiles, robustness comparison, sensitivity review,
# and simple reproducible visual outputs.

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

summary_path <- file.path(tables_dir, "decision_summary.csv")
regret_path <- file.path(tables_dir, "decision_regret_matrix.csv")
mcda_path <- file.path(tables_dir, "decision_mcda_scores.csv")
sensitivity_path <- file.path(tables_dir, "decision_sensitivity_analysis.csv")

required_files <- c(summary_path, regret_path, mcda_path, sensitivity_path)
missing_files <- required_files[!file.exists(required_files)]

if (length(missing_files) > 0) {
  stop(paste("Missing required files. Run the Python workflow first:", paste(missing_files, collapse = ", ")))
}

decision_summary <- read.csv(summary_path, stringsAsFactors = FALSE)
regret_matrix <- read.csv(regret_path, stringsAsFactors = FALSE)
mcda_scores <- read.csv(mcda_path, stringsAsFactors = FALSE)
sensitivity <- read.csv(sensitivity_path, stringsAsFactors = FALSE)

decision_summary <- decision_summary[order(
  -decision_summary$robustness_share,
  -decision_summary$expected_value,
  decision_summary$maximum_regret,
  -decision_summary$mcda_score
), ]

top_alternative <- decision_summary$alternative[1]

regret_profile <- aggregate(
  regret ~ alternative,
  data = regret_matrix,
  FUN = function(x) c(mean = mean(x), max = max(x), sd = sd(x))
)

regret_profile_expanded <- data.frame(
  alternative = regret_profile$alternative,
  average_regret = regret_profile$regret[, "mean"],
  maximum_regret = regret_profile$regret[, "max"],
  regret_sd = regret_profile$regret[, "sd"]
)

sensitivity_instability <- aggregate(
  ranking_changed ~ changed_criterion,
  data = sensitivity,
  FUN = function(x) mean(as.logical(x))
)

names(sensitivity_instability) <- c("criterion", "ranking_instability_rate")

diagnostic_report <- merge(decision_summary, regret_profile_expanded, by = "alternative", all.x = TRUE)
diagnostic_report <- diagnostic_report[order(
  -diagnostic_report$robustness_share,
  diagnostic_report$maximum_regret.y,
  -diagnostic_report$expected_value
), ]

diagnostic_report$interpretive_status <- ifelse(
  diagnostic_report$alternative == top_alternative,
  "current recommended candidate",
  ifelse(
    diagnostic_report$maximum_regret.y > quantile(diagnostic_report$maximum_regret.y, 0.75),
    "regret-sensitive alternative",
    "comparison alternative"
  )
)

write.csv(
  diagnostic_report,
  file.path(tables_dir, "decision_diagnostic_report.csv"),
  row.names = FALSE
)

write.csv(
  sensitivity_instability,
  file.path(tables_dir, "decision_weight_instability_summary.csv"),
  row.names = FALSE
)

plot_bar <- function(values, names, title, y_label, file_name) {
  png(file.path(figures_dir, file_name), width = 1200, height = 750)
  barplot(
    values,
    names.arg = names,
    las = 2,
    ylab = y_label,
    main = title
  )
  grid()
  dev.off()
}

plot_bar(
  decision_summary$expected_value,
  decision_summary$alternative,
  "Expected Value by Alternative",
  "Expected value",
  "expected_value_by_alternative.png"
)

plot_bar(
  decision_summary$maximum_regret,
  decision_summary$alternative,
  "Maximum Regret by Alternative",
  "Maximum regret",
  "maximum_regret_by_alternative.png"
)

plot_bar(
  decision_summary$robustness_share,
  decision_summary$alternative,
  "Robustness Share by Alternative",
  "Share of scenarios meeting threshold",
  "robustness_share_by_alternative.png"
)

plot_bar(
  decision_summary$mcda_score,
  decision_summary$alternative,
  "MCDA Score by Alternative",
  "Weighted MCDA score",
  "mcda_score_by_alternative.png"
)

plot_bar(
  sensitivity_instability$ranking_instability_rate,
  sensitivity_instability$criterion,
  "Ranking Instability by Criterion",
  "Share of perturbations changing top rank",
  "ranking_instability_by_criterion.png"
)

print(decision_summary)
print(diagnostic_report)
print(sensitivity_instability)

This R workflow supports the article’s central methodological claim: decision analysis should not stop at a single ranking. It should examine expected value, regret, robustness, multi-criteria performance, and sensitivity to assumptions. The outputs help readers see whether the recommended alternative is stable, fragile, regret-sensitive, or dependent on contested weights.

Back to top ↑

GitHub Repository

The companion repository for this article should help readers model decision science through expected value, expected utility, decision trees, regret analysis, robustness diagnostics, scenario comparison, multi-criteria decision analysis, sensitivity analysis, decision records, and reproducible decision summaries using synthetic datasets and professional workflow scaffolds.

articles/what-is-decision-science/
├── python/
│   ├── decision_science_diagnostics_workflow.py
│   ├── expected_value_utility_model.py
│   ├── decision_tree_diagnostics.py
│   ├── regret_analysis_minimax.py
│   ├── robustness_scenario_comparison.py
│   ├── sensitivity_threshold_analysis.py
│   ├── decision_record_generator.py
│   ├── validation_checks.py
│   └── run_all_decision_science_workflows.py
├── r/
│   ├── decision_science_summary_reporting.R
│   ├── mcda_tradeoff_profiles.R
│   ├── sensitivity_weight_diagnostics.R
│   ├── regret_profile_summary.R
│   ├── robustness_visualization.R
│   ├── decision_record_tables.R
│   └── run_all_decision_science_workflows.R
├── julia/
│   ├── high_performance_scenario_scan.jl
│   ├── robustness_frontier_analysis.jl
│   └── regret_surface_diagnostics.jl
├── sql/
│   ├── schema_alternatives.sql
│   ├── schema_criteria.sql
│   ├── schema_assumptions.sql
│   ├── schema_evidence.sql
│   ├── schema_scenarios.sql
│   ├── schema_model_runs.sql
│   ├── schema_decision_records.sql
│   └── schema_outputs.sql
├── rust/
│   └── decision_diagnostics_cli.rs
├── go/
│   └── scenario_utility_runner.go
├── cpp/
│   ├── efficient_expected_value_scan.cpp
│   └── regret_matrix_solver.cpp
├── fortran/
│   └── numerical_decision_model.f90
├── c/
│   └── low_level_expected_value_utils.c
├── docs/
│   ├── modeling_principles.md
│   ├── article_notes.md
│   ├── decision_science_framework.md
│   ├── expected_value_and_utility_notes.md
│   ├── regret_and_robustness_guide.md
│   ├── mcda_interpretation_notes.md
│   ├── python_workflow.md
│   ├── r_workflow.md
│   ├── diagnostic_questions.md
│   ├── assumptions_and_limitations.md
│   └── responsible_use.md
├── data/
│   ├── synthetic_alternatives.csv
│   ├── synthetic_criteria.csv
│   ├── synthetic_assumptions.csv
│   ├── synthetic_evidence.csv
│   ├── synthetic_scenarios.csv
│   ├── synthetic_model_runs.csv
│   └── synthetic_decision_records.csv
├── outputs/
│   ├── README.md
│   ├── figures/
│   ├── tables/
│   └── decision_records/
└── notebooks/
    ├── python_decision_science_walkthrough.ipynb
    └── r_mcda_sensitivity_placeholder.ipynb

This repository structure supports the article’s central argument: decision science should connect structured judgment, uncertainty, evidence, probability, values, trade-offs, computation, accountability, and learning. The python/ folder supports expected value, decision trees, regret analysis, robustness, and scenario comparison. The r/ folder supports MCDA, sensitivity analysis, trade-off profiles, and reproducible decision summaries. The julia/ folder supports high-performance scenario and robustness examples. The sql/ folder defines alternatives, criteria, assumptions, evidence, scenarios, model runs, and decision records. The lower-level language folders provide scaffolds for efficient diagnostics, utility scoring, numerical decision models, and low-level expected-value utilities.

Back to top ↑

Back to top ↑

Common Pitfalls

Decision science can improve judgment, but it can also be misused. The most common misuse is false precision. A model may assign numerical values to uncertain inputs, produce a clean ranking, and create the appearance of objectivity even when the underlying assumptions are weak. When numbers become a substitute for judgment, decision science has been distorted.

A strong decision-science process remains humble about uncertainty, explicit about values, transparent about assumptions, and clear about responsibility.

Back to top ↑

Why Decision Science Requires Structured Judgment

Decision science matters because consequential decisions are rarely made under ideal conditions. They are made in the presence of partial knowledge, conflicting objectives, incomplete models, behavioral limits, institutional constraints, and changing environments. In such settings, intuition is not enough, but formal optimization alone is not enough either.

What decision science offers is a disciplined way to connect analysis with judgment. It makes assumptions visible, forces trade-offs into the open, distinguishes risk from deeper uncertainty, and helps decision-makers evaluate not only which options are attractive, but which remain defensible when the world does not behave as expected.

Its importance is increasing because modern decision environments are becoming more interconnected. Climate adaptation, AI governance, public health, financial stability, infrastructure resilience, energy transition, democratic accountability, and organizational strategy all require structured reasoning under uncertainty. These are not decisions where a single metric can responsibly decide the issue. They require analytical rigor, behavioral realism, systems awareness, ethical clarity, and institutional learning.

Decision science does not eliminate judgment. It improves the conditions under which judgment is made.

Back to top ↑

Related Articles

• Decision Science vs. Decision Theory
• Why Uncertainty Changes Decision-Making
• The History of Decision Science
• Core Principles of Decision Science
• Expected Value and Expected Utility
• Decision Trees and Structured Choice
• Risk Analysis and Probabilistic Reasoning
• Bayesian Decision-Making
• Sensitivity Analysis and Scenario Comparison
• Multi-Criteria Decision Analysis

Back to top ↑

Further Reading

• Howard, R.A. and Abbas, A.E. (2023) Foundations of Decision Analysis. Harlow: Pearson. Available at: https://www.pearson.com/en-us/subject-catalog/p/foundations-of-decision-analysis/P200000003532/9780137981878
• Kahneman, D. (2013) Thinking, Fast and Slow. New York: Farrar, Straus and Giroux. Available at: https://us.macmillan.com/books/9780374533557/thinkingfastandslow
• Keeney, R.L. (1992) Value-Focused Thinking: A Path to Creative Decisionmaking. Cambridge, MA: Harvard University Press.
• Knight, F.H. (1921) Risk, Uncertainty, and Profit. Boston, MA: Houghton Mifflin. Available at: https://oll.libertyfund.org/titles/knight-risk-uncertainty-and-profit
• March, J.G. (1994) A Primer on Decision Making: How Decisions Happen. New York: Free Press.
• Raiffa, H. (1968) Decision Analysis: Introductory Lectures on Choices Under Uncertainty. Reading, MA: Addison-Wesley.
• Simon, H.A. (1997) Administrative Behavior: A Study of Decision-Making Processes in Administrative Organizations. 4th edn. New York: Free Press.
• Tetlock, P.E. and Gardner, D. (2015) Superforecasting: The Art and Science of Prediction. New York: Crown. Available at: https://www.penguinrandomhouse.com/books/248772/superforecasting-by-philip-tetlock-and-dan-gardner/

Back to top ↑

References

• Howard, R.A. (1966) “Decision Analysis: Applied Decision Theory.” Proceedings of the Fourth International Conference on Operational Research.
• Howard, R.A. and Abbas, A.E. (2023) Foundations of Decision Analysis. Harlow: Pearson. Available at: https://www.pearson.com/en-us/subject-catalog/p/foundations-of-decision-analysis/P200000003532/9780137981878
• Kahneman, D. and Tversky, A. (1979) “Prospect Theory: An Analysis of Decision under Risk.” Econometrica, 47(2), pp. 263–291.
• Keeney, R.L. (1992) Value-Focused Thinking: A Path to Creative Decisionmaking. Cambridge, MA: Harvard University Press.
• Knight, F.H. (1921) Risk, Uncertainty, and Profit. Boston, MA: Houghton Mifflin. Available at: https://oll.libertyfund.org/titles/knight-risk-uncertainty-and-profit
• March, J.G. (1994) A Primer on Decision Making: How Decisions Happen. New York: Free Press.
• Raiffa, H. (1968) Decision Analysis: Introductory Lectures on Choices Under Uncertainty. Reading, MA: Addison-Wesley.
• RAND Corporation (n.d.) “Robust Decision Making.” Available at: https://www.rand.org/topics/robust-decision-making.html
• RAND Corporation (2013) “Making Good Decisions Without Predictions.” Available at: https://www.rand.org/pubs/research_briefs/RB9701.html
• Savage, L.J. (1954) The Foundations of Statistics. New York: Wiley.
• Simon, H.A. (1978) “Rational Decision-Making in Business Organizations.” Nobel Prize lecture. Available at: https://www.nobelprize.org/prizes/economic-sciences/1978/simon/lecture/
• 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
• von Neumann, J. and Morgenstern, O. (1944) Theory of Games and Economic Behavior. Princeton, NJ: Princeton University Press.

Back to top ↑