The History of Decision Science

Last Updated June 5, 2026

The history of decision science is the history of how probability, judgment, strategy, psychology, computation, systems thinking, and institutional practice gradually converged into a field devoted to making better choices under uncertainty. What began as mathematical reflection on chance and value became a broader inquiry into how real people, organizations, governments, and technical systems reason when information is incomplete, values conflict, outcomes are uncertain, and consequences unfold across time.

The History of Decision Science examines the field’s development from probability theory and expected utility to operations research, game theory, decision analysis, bounded rationality, behavioral research, systems modeling, robust decision-making, and contemporary decision support. It shows why decision science cannot be reduced to one method, one discipline, or one theory of rationality. Its history is layered: formal probability, subjective belief, optimization, satisficing, cognitive bias, institutional judgment, computational modeling, and robustness all remain part of the field’s working vocabulary.

This article traces the intellectual development of decision science as a cumulative field rather than a linear replacement of old methods by new ones. Probability theory made uncertainty analyzable. Expected utility connected chance with value. Statistics and subjective probability connected belief with action. Operations research and decision analysis brought formal models into organizations. Game theory added strategic interaction. Bounded rationality and behavioral research exposed the limits of idealized optimization. Systems thinking, scenario analysis, and robust decision-making expanded the field toward complexity, uncertainty, and resilience. The article also includes a mathematical lens, an R workflow for comparing historical decision paradigms, a Python workflow for simulating expected-value, satisficing, and robust agents, and a companion GitHub structure for reproducible decision-science history workflows.

Why the History of Decision Science Matters

The history of decision science matters because the field’s central tensions were built into it from the beginning. Is better decision-making primarily a matter of logical consistency, practical judgment, institutional design, behavioral correction, or adaptive learning? Should a good decision be defined by expected utility, robustness across futures, legitimacy of process, quality of evidence, or the ability to revise when conditions change? Are decision-makers best modeled as rational maximizers, bounded searchers, strategic actors, social participants, or institutional agents?

These questions emerged gradually as different intellectual traditions encountered the same recurring problem: how should choices be made when the future is uncertain and consequences matter? Early probability theory made chance analyzable. Expected utility connected chance to subjective value. Statistics connected incomplete evidence to inference. Operations research brought mathematical models into urgent organizational settings. Game theory showed that many outcomes depend on the choices of other actors. Psychology showed that real judgment deviates systematically from idealized rationality. Systems thinking widened the frame toward feedback, delay, interdependence, and adaptation.

The history therefore explains why decision science is not a single technique. It is a layered field. It contains formal decision theory and applied decision analysis, probability and psychology, optimization and satisficing, predictive modeling and robust planning, expert judgment and computational workflow, institutional governance and post-decision learning.

Historical development pushed the field toward synthesis. Mathematical elegance without behavioral realism was too narrow. Psychological realism without formal structure was too loose. Optimization without institutional context could mislead. Systems awareness without decision discipline could become descriptive rather than actionable. Decision science emerged from the need to hold these elements together.

Back to top ↑

Probability, Value, and the Earliest Foundations

The earliest foundations of decision science lie in probability theory. Seventeenth-century work associated with Blaise Pascal and Pierre de Fermat helped establish the mathematics of chance. Questions originally framed through gambling and games of chance became more general questions about uncertainty, expectation, and rational comparison. Later work by Christiaan Huygens, Jakob Bernoulli, Thomas Bayes, and Pierre-Simon Laplace expanded probability into a central tool of scientific reasoning, inference, insurance, demography, astronomy, and public administration.

This development changed the status of uncertainty. Uncertainty was no longer only a condition to fear, narrate, or interpret morally. In some settings, it could be measured, modeled, compared, and used in structured reasoning. That was a profound shift. Once chance could be assigned probabilities, choice under uncertainty could be treated analytically rather than only intuitively.

But probability alone did not yet produce decision science. A probability distribution tells us how likely outcomes are, but it does not tell us how much those outcomes matter. A gain of one hundred dollars does not have the same significance for every person, institution, or situation. A small probability of catastrophic harm cannot always be compared cleanly with a large probability of moderate benefit. The need to connect probability with value opened the door to expected utility and, later, to formal decision theory.

Decision science begins when uncertainty is not merely described, but connected to action. Probability created the first formal language for that connection, but the field had to expand once it became clear that probability-weighted payoff was not the same as decision quality.

Back to top ↑

Expected Utility and the Formalization of Choice

A pivotal moment in the history of decision science came with Daniel Bernoulli’s treatment of the St. Petersburg paradox. The paradox showed that a gamble with infinite expected monetary value may still be unattractive to a real decision-maker. Bernoulli’s key insight was that decision-makers do not experience value as raw monetary magnitude. They experience utility. Additional wealth may have diminishing marginal value, and the subjective significance of gains and losses may differ from their nominal size.

This insight created one of the most important conceptual shifts in the field. Rational choice under uncertainty was no longer simply about expected monetary value. It was about expected utility. That distinction allowed decision models to represent risk attitudes, diminishing marginal value, and the difference between external payoff and internal valuation.

Later work in economics and statistics formalized expected utility through axiomatic systems. The von Neumann-Morgenstern expected utility theorem showed how consistent preferences over lotteries could be represented by a utility function under certain assumptions. Leonard Savage extended the framework toward subjective probability and choice under uncertainty. These developments helped define decision theory as a formal account of coherent choice.

Expected utility became foundational for economics, finance, insurance, welfare analysis, risk analysis, and formal decision theory. Its strength was clarity. It made explicit the relationship among actions, states, outcomes, probabilities, and preferences. Its weakness was also historically important: the model’s normative elegance did not fully describe how people and institutions actually decide.

The later history of decision science can be read as a series of responses to this tension. Some traditions refined expected utility. Others challenged its behavioral realism. Still others embedded it in broader methods of decision analysis, institutional process, and robust planning.

Back to top ↑

Risk, Uncertainty, and Economic Judgment

Frank Knight’s distinction between risk and uncertainty became one of the field’s enduring conceptual foundations. In Risk, Uncertainty, and Profit, Knight distinguished situations where probabilities can be measured from situations where they cannot be reduced to known distributions. This distinction remains central because it marks a boundary between calculable risk and deeper forms of uncertainty.

Under risk, a decision-maker may reasonably use expected value, expected utility, actuarial models, reliability analysis, or decision trees. Under uncertainty, the probability structure itself may be unknown, unstable, or contested. This changes the nature of decision-making. Calculation remains useful, but it cannot fully replace judgment, interpretation, prudence, and institutional learning.

Knight’s distinction had major implications for entrepreneurship, public policy, finance, technological change, geopolitical strategy, and long-range planning. In these domains, the future is often not a repeatable lottery. Historical data may be sparse or misleading. Structural conditions may shift. Decision-makers may disagree about the relevant model. New events may create outcomes that were not fully imagined in advance.

Knight broadened decision science beyond the mathematics of known risk. He forced the field to confront a harder question: what does rationality look like when probability itself is uncertain? That question continues through later work on ambiguity, scenario planning, deep uncertainty, and robust decision-making.

Back to top ↑

Statistics, Subjective Probability, and the Logic of Belief

Another major strand in the development of decision science involved statistics, inference, and the formal treatment of belief. Many important decisions are made under conditions where repeated frequencies are unavailable or incomplete. Strategic choices, policy judgments, medical decisions, safety assessments, legal judgments, and high-consequence organizational decisions often rely on expert belief, limited evidence, and inferential reasoning.

The development of subjective probability widened the scope of decision analysis. Leonard Savage’s work helped connect rational choice with coherent personal degrees of belief. The central idea was not that subjective belief is arbitrary. It was that beliefs can be evaluated for coherence and integrated with preferences in a formal decision framework.

This was historically significant because it made decision theory applicable to unique and high-stakes decisions. A government deciding on a policy, a company deciding on a technology investment, or a medical team deciding on treatment may not have repeated identical trials. Subjective probability offered a way to incorporate expert judgment while retaining formal discipline.

Bayesian decision-making further strengthened the connection between evidence and action. Priors, likelihoods, posterior beliefs, and decision rules became part of a unified logic. The point was not merely to estimate what is true. It was to decide what to do given evidence, uncertainty, and consequences.

Decision science inherited this logic, but widened it. It asks not only whether beliefs are coherent, but whether evidence is credible, whether experts disagree, whether assumptions are documented, whether values are transparent, and whether decision records preserve the reasoning for later review.

Back to top ↑

War, Strategy, and the Rise of Operations Research

The Second World War transformed the practical environment in which decision methods developed. Governments faced urgent problems in logistics, radar deployment, convoy protection, targeting, resource allocation, production planning, and military coordination. These were not abstract puzzles. They were operational choices with immediate consequences, limited information, scarce resources, and high stakes.

Operations research emerged from this context as a field committed to improving decisions through formal analysis. It brought mathematics, statistics, engineering, economics, and organizational problem-solving into direct contact with real institutional decisions. Wartime operations research demonstrated that decision methods could shape actual practice, not merely theoretical debates.

This period mattered enormously for decision science because it normalized the idea that decision quality could be systematically improved. Modeling, optimization, simulation, queuing theory, inventory analysis, logistics, and resource allocation became part of institutional decision support. The field moved from abstract rational choice toward applied problem-solving in complex organizations.

The practical ethos of operations research remains embedded in decision science today. Whenever analysts model trade-offs, allocate scarce resources, simulate systems, optimize portfolios, stress test alternatives, or compare scenarios, they are working within a lineage shaped by operations research.

Back to top ↑

Decision Analysis as a Distinct Discipline

Decision analysis emerged as a more explicit and self-conscious discipline in the twentieth century, especially through work associated with Ronald Howard and the Stanford decision analysis tradition. Decision analysis focused not only on prediction or optimization, but on the disciplined structuring of choice itself.

This distinction is crucial. Decision analysis asks: What is the decision? Who owns it? What are the alternatives? What uncertainties matter? What values are relevant? What evidence would improve the decision? What trade-offs must be made explicit? What information is worth gathering before commitment?

Decision analysis helped transform decision science from a loose collection of methods into a practical methodology. It emphasized decision framing, value of information, influence diagrams, decision trees, utility assessment, uncertainty representation, sensitivity analysis, and clarity about objectives. It gave analysts a way to support decision-makers without pretending that models alone could make decisions responsibly.

The emergence of decision analysis also reinforced a core principle of modern decision science: better decisions require more than data. They require clarity about the decision itself. A technically sophisticated model can fail if the alternatives are weak, the frame is wrong, the relevant values are hidden, or the decision-maker is unclear about what must actually be chosen.

Back to top ↑

Game Theory, Strategic Interaction, and Conflict

Game theory expanded decision science by showing that many decisions are not choices against nature alone. They are choices involving other strategic actors. Negotiation, deterrence, market competition, bargaining, regulation, geopolitical conflict, platform governance, coalition formation, and institutional design all involve outcomes that depend on how others respond.

The work of John von Neumann and Oskar Morgenstern helped formalize strategic interaction. Game theory introduced concepts such as strategy, payoff, equilibrium, dominance, mixed strategy, signaling, credible commitment, and strategic interdependence. This changed the scope of decision science. A good decision could no longer be understood only as the best response to a fixed environment. It might need to anticipate counter-moves, incentives, information asymmetry, and institutional rules.

Game theory also affected economics, political science, military strategy, organizational theory, and public policy. It provided a formal language for conflict and cooperation. It also revealed a difficult truth: individually rational choices can produce collectively poor outcomes when incentives are misaligned.

Although game theory is often treated as a separate field, it remains deeply connected to decision science. It shows that structured judgment must often include other agents, institutional incentives, and the strategic consequences of action.

Back to top ↑

Bounded Rationality and the Behavioral Turn

If expected utility and game theory represent the high formalism of rational choice, Herbert Simon represents one of the field’s most important correctives. Simon argued that real decision-makers operate under constraints of time, information, attention, and computational capacity. They do not optimize across all conceivable alternatives. They search, simplify, use routines, and often satisfice: they select an option that is good enough relative to an aspiration level.

Bounded rationality was a turning point because it challenged the descriptive adequacy of idealized optimization. It did not reject formal reasoning. Instead, it asked how real decision processes work when decision-makers are limited and embedded in organizations. This shifted attention from the final choice to the process through which alternatives are generated, evidence is filtered, priorities are set, and action becomes possible.

Simon’s work influenced public administration, management, organizational theory, economics, artificial intelligence, and cognitive science. It helped make decision science more realistic without making it less rigorous. The question became: how can decision environments be designed so that bounded decision-makers can still perform well?

Bounded rationality remains central to decision science because many decisions are made under constraints that make exhaustive optimization impossible. The practical task is not to pretend those limits do not exist. It is to build decision processes, tools, records, and review practices that improve judgment despite them.

Back to top ↑

Heuristics, Biases, and Behavioral Economics

The behavioral turn deepened through the work of Amos Tversky, Daniel Kahneman, and many others who studied judgment under uncertainty. Their research showed that people rely on heuristics: mental shortcuts that simplify complex judgments. These shortcuts can be useful, but they can also generate systematic errors.

Availability can make vivid or recent events seem more likely than they are. Representativeness can cause people to ignore base rates. Anchoring can make initial estimates disproportionately influential. Framing effects can change preferences depending on how equivalent information is presented. Loss aversion can make losses weigh more heavily than comparable gains. Overconfidence can make uncertainty intervals too narrow and forecasts too certain.

These findings challenged the descriptive realism of classical rational-choice models. They also transformed decision support. If predictable errors shape judgment, then better decision-making requires process design: calibration, base-rate checks, reference classes, independent estimates, structured dissent, pre-mortems, red teams, decision hygiene, and post-decision review.

Behavioral economics integrated many of these insights into economic and policy thinking. For decision science, the implication was clear: effective decision support must account not only for logic and information, but also for cognition, attention, framing, incentives, and institutional culture.

Back to top ↑

Systems Thinking, Complexity, and Dynamic Decision Contexts

As policy, finance, healthcare, infrastructure, environmental governance, and technology systems became more complex, decision science increasingly incorporated systems thinking. Many decisions do not produce isolated outcomes. They interact with dynamic systems shaped by feedback loops, delays, adaptation, path dependence, interdependence, and nonlinear change.

In such environments, static choice models are often insufficient. A policy may solve one problem while intensifying another through delayed effects. A short-term optimization may erode long-term resilience. A financial intervention may reduce immediate volatility while increasing systemic fragility. A technology decision may look efficient locally while creating lock-in, dependency, or cascading risk elsewhere.

Systems thinking widened the temporal and structural lens of decision science. The decision-maker must ask not only which option is best now, but how the decision changes the system that later determines outcomes. This connects decision science to system dynamics, scenario modeling, agent-based modeling, resilience analysis, and complex adaptive systems research.

This systems orientation is one reason modern decision science is closely related to sustainability, public policy, infrastructure planning, AI governance, financial risk, and resilience. In these fields, good decisions must account for feedback, delay, adaptation, and second-order consequences.

Back to top ↑

From Optimization to Robust Decision-Making

In recent decades, decision science has shifted increasingly from optimization under well-specified assumptions toward robustness under deep uncertainty. Classical models often ask: what is the best option given the estimated probabilities and outcomes? Robust approaches ask a different question: which strategies perform acceptably across many plausible futures?

This shift is especially important in climate adaptation, water planning, infrastructure, national security, public health, finance, and long-term policy. In these domains, probabilities may be disputed, models may disagree, consequences may unfold over decades, and stakeholder values may be contested. A strategy optimized for one forecast may fail badly when the future departs from that forecast.

Robust decision-making does not reject analysis. It changes the evaluative standard. It emphasizes vulnerability analysis, scenario discovery, regret, thresholds, stress testing, adaptive pathways, and learning. A robust strategy may sacrifice some upside under one forecast in exchange for acceptable performance across a wider range of futures.

Historically, this represents an evolution in the meaning of rationality. Under deep uncertainty, rationality may require flexibility rather than precision, adaptiveness rather than single-point optimization, and vulnerability analysis rather than confidence in forecasts.

Back to top ↑

Computing, Data, and Contemporary Decision Support

The rise of computing changed decision science again. Optimization, simulation, Bayesian computation, Monte Carlo methods, agent-based modeling, machine learning, decision dashboards, and large-scale data systems expanded what analysts could model and compare. Decisions that once required simplified analytical solutions could now be explored through computational experiments.

This computational turn made decision science more powerful, but also more vulnerable to new forms of error. Larger models can hide assumptions. More data can create false confidence. Machine learning systems can optimize prediction while leaving decision values unclear. Dashboards can make uncertainty appear cleaner than it is. Automated systems can shift accountability away from human institutions.

Contemporary decision science therefore must distinguish prediction from decision. A predictive model estimates what may happen. A decision model asks what should be done, given uncertainty, values, costs, benefits, risks, constraints, and accountability. The two are related, but not identical.

The computational history of decision science reinforces the field’s central lesson: better tools do not eliminate the need for better judgment. They make the architecture of judgment more important.

Back to top ↑

Decision Science Today

Today, decision science is best understood as an interdisciplinary field for improving judgment and action under uncertainty. It draws on economics, statistics, psychology, operations research, systems theory, computer science, public policy, organizational research, ethics, and governance. Its methods range from expected utility models and decision trees to Bayesian analysis, behavioral experiments, multi-criteria decision analysis, scenario planning, agent-based modeling, Monte Carlo simulation, robust decision-making, and decision records.

What unifies these approaches is not a single technique. It is a shared concern with structured choice. Modern decision science asks decision-makers to clarify objectives, compare alternatives, examine assumptions, represent uncertainty, evaluate trade-offs, test robustness, document rationale, and learn from outcomes.

The field’s breadth is a strength because complex decisions rarely yield to one framework alone. A healthcare decision may require evidence appraisal, patient values, risk communication, and clinical judgment. A climate adaptation decision may require scenarios, thresholds, equity analysis, long-term uncertainty, and adaptive pathways. An AI governance decision may require model evaluation, institutional accountability, stakeholder legitimacy, and monitoring. A financial risk decision may require probability modeling, stress testing, behavioral incentives, and systemic-risk awareness.

Contemporary decision science is strongest when it combines formal rigor, behavioral realism, system awareness, and institutional accountability.

Back to top ↑

Historical Synthesis: What Each Tradition Contributed

The development of decision science can be understood as a series of cumulative contributions. Each tradition solved part of the decision problem and exposed new limitations that later traditions had to address.

The field’s history therefore should not be read as a sequence of discarded ideas. Expected utility did not disappear when bounded rationality emerged. Optimization did not disappear when robustness became important. Formal theory did not disappear when behavioral research exposed bias. Instead, decision science became a layered field in which different tools apply under different assumptions.

Back to top ↑

Back to top ↑

Mathematical Lens: Expected Utility, Subjective Belief, Regret, and Robustness

The mathematical history of decision science can be understood as a widening sequence of formal representations. Early probabilistic reasoning emphasized expected monetary value. Expected utility introduced subjective value. Subjective probability allowed belief to enter the model. Regret and robustness expanded the field toward deep uncertainty and multiple futures.

Expected monetary value evaluates an action by probability-weighted payoff:

Expected utility replaces raw payoff with subjective value:

Subjective expected utility allows probabilities to represent coherent belief:

Bayesian decision-making updates belief after evidence:

Bounded rationality can be represented through satisficing:

Regret compares an action with the best action that would have been chosen if the state had been known:

Minimax regret selects the strategy with the smallest worst-case regret:

Robustness measures acceptable performance across futures:

This mathematical progression captures the field’s historical expansion. Decision science began with probability-weighted expectation, but it did not stop there. It grew as scholars and practitioners recognized that real decisions also require utility, belief, learning, bounded cognition, strategic interaction, systems awareness, and robustness.

Back to top ↑

R Workflow: Historical Decision Paradigms, Expected Utility, Subjective Belief, and Robust Regret

The R workflow below compares several historical decision paradigms: expected monetary value, expected utility, subjective expected utility, minimax regret, robustness, and satisficing thresholds. It uses base R for portability, writes reproducible tables, and generates diagnostic plots.

# history_of_decision_science_workflow.R
# Base R workflow for comparing historical decision paradigms:
# expected monetary value, expected utility, subjective belief,
# minimax regret, robustness, and satisficing thresholds.

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

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

payoff_table <- data.frame(
  scenario = c("Stable Growth", "Moderate Shock", "Severe Disruption", "Institutional Constraint"),
  objective_probability = c(0.42, 0.28, 0.18, 0.12),
  subjective_probability = c(0.30, 0.34, 0.24, 0.12),
  Aggressive = c(128, 50, -90, -20),
  Balanced = c(92, 68, 18, 42),
  Defensive = c(62, 58, 44, 54),
  Adaptive = c(88, 70, 36, 72),
  check.names = FALSE
)

validate_probabilities <- function(probabilities, label) {
  total <- sum(probabilities)
  if (abs(total - 1) > 1e-8) {
    stop(paste(label, "must sum to 1. Current sum:", total))
  }
}

validate_probabilities(payoff_table$objective_probability, "Objective probabilities")
validate_probabilities(payoff_table$subjective_probability, "Subjective probabilities")

strategies <- setdiff(
  names(payoff_table),
  c("scenario", "objective_probability", "subjective_probability")
)

utility_function <- function(x, risk_aversion = 0.016) {
  1 - exp(-risk_aversion * x)
}

expected_value <- function(payoff, probability) {
  sum(payoff * probability)
}

expected_utility <- function(payoff, probability) {
  sum(utility_function(payoff) * probability)
}

robustness_share <- function(payoff, threshold = 40) {
  mean(payoff >= threshold)
}

long_rows <- data.frame()

for (strategy in strategies) {
  temp <- data.frame(
    scenario = payoff_table$scenario,
    objective_probability = payoff_table$objective_probability,
    subjective_probability = payoff_table$subjective_probability,
    strategy = strategy,
    payoff = payoff_table[[strategy]],
    stringsAsFactors = FALSE
  )
  long_rows <- rbind(long_rows, temp)
}

best_by_scenario <- apply(payoff_table[, strategies], 1, max)

regret_rows <- data.frame()

for (strategy in strategies) {
  temp <- data.frame(
    scenario = payoff_table$scenario,
    strategy = strategy,
    payoff = payoff_table[[strategy]],
    best_payoff = best_by_scenario,
    regret = best_by_scenario - payoff_table[[strategy]],
    stringsAsFactors = FALSE
  )
  regret_rows <- rbind(regret_rows, temp)
}

summary_rows <- data.frame()

for (strategy in strategies) {
  payoff <- payoff_table[[strategy]]
  strategy_regret <- regret_rows$regret[regret_rows$strategy == strategy]

  temp <- data.frame(
    strategy = strategy,
    expected_monetary_value = expected_value(payoff, payoff_table$objective_probability),
    expected_utility = expected_utility(payoff, payoff_table$objective_probability),
    subjective_expected_utility = expected_utility(payoff, payoff_table$subjective_probability),
    minimum_payoff = min(payoff),
    maximum_payoff = max(payoff),
    maximum_regret = max(strategy_regret),
    average_regret = mean(strategy_regret),
    robustness_share = robustness_share(payoff, threshold = 40),
    satisficing_share = robustness_share(payoff, threshold = 50),
    stringsAsFactors = FALSE
  )

  summary_rows <- rbind(summary_rows, temp)
}

summary_rows$emv_rank <- rank(-summary_rows$expected_monetary_value, ties.method = "min")
summary_rows$eu_rank <- rank(-summary_rows$expected_utility, ties.method = "min")
summary_rows$subjective_eu_rank <- rank(-summary_rows$subjective_expected_utility, ties.method = "min")
summary_rows$minimax_regret_rank <- rank(summary_rows$maximum_regret, ties.method = "min")
summary_rows$robustness_rank <- rank(-summary_rows$robustness_share, ties.method = "min")

summary_rows$historical_profile <- ifelse(
  summary_rows$emv_rank == 1,
  "classical expected-value candidate",
  ifelse(
    summary_rows$minimax_regret_rank == 1,
    "robust regret-minimization candidate",
    ifelse(
      summary_rows$robustness_rank == 1,
      "robust threshold candidate",
      ifelse(
        summary_rows$subjective_eu_rank == 1,
        "subjective expected-utility candidate",
        "comparison strategy"
      )
    )
  )
)

summary_rows <- summary_rows[order(
  summary_rows$robustness_rank,
  summary_rows$minimax_regret_rank,
  summary_rows$emv_rank
), ]

write.csv(payoff_table, file.path(tables_dir, "historical_paradigm_payoff_table.csv"), row.names = FALSE)
write.csv(long_rows, file.path(tables_dir, "historical_paradigm_long_payoffs.csv"), row.names = FALSE)
write.csv(regret_rows, file.path(tables_dir, "historical_paradigm_regret_table.csv"), row.names = FALSE)
write.csv(summary_rows, file.path(tables_dir, "historical_paradigm_comparison.csv"), row.names = FALSE)

png(file.path(figures_dir, "expected_monetary_value_by_strategy.png"), width = 1200, height = 800)
barplot(
  summary_rows$expected_monetary_value,
  names.arg = summary_rows$strategy,
  las = 2,
  main = "Expected Monetary Value by Strategy",
  ylab = "Expected monetary value"
)
grid()
dev.off()

png(file.path(figures_dir, "maximum_regret_by_strategy.png"), width = 1200, height = 800)
barplot(
  summary_rows$maximum_regret,
  names.arg = summary_rows$strategy,
  las = 2,
  main = "Maximum Regret by Strategy",
  ylab = "Maximum regret"
)
grid()
dev.off()

png(file.path(figures_dir, "robustness_share_by_strategy.png"), width = 1200, height = 800)
barplot(
  summary_rows$robustness_share,
  names.arg = summary_rows$strategy,
  las = 2,
  main = "Robustness Share by Strategy",
  ylab = "Share of scenarios meeting threshold"
)
grid()
dev.off()

png(file.path(figures_dir, "historical_rank_comparison.png"), width = 1200, height = 800)
rank_matrix <- t(as.matrix(summary_rows[, c(
  "emv_rank",
  "eu_rank",
  "subjective_eu_rank",
  "minimax_regret_rank",
  "robustness_rank"
)]))
barplot(
  rank_matrix,
  beside = TRUE,
  names.arg = summary_rows$strategy,
  las = 2,
  main = "Rank Comparison Across Historical Decision Paradigms",
  ylab = "Rank"
)
legend("topright", legend = rownames(rank_matrix), bty = "n")
grid()
dev.off()

print(summary_rows)

This R workflow makes the field’s history visible as competing decision criteria. The expected-value candidate may not be the expected-utility candidate. The subjective-belief candidate may differ from the minimax-regret candidate. The robust threshold candidate may not maximize expected payoff. That divergence is precisely why decision science became broader than formal optimization alone.

Back to top ↑

Python Workflow: Bounded Rationality, Noisy Choice, Robustness, and Historical Decision Agents

The Python workflow below simulates repeated decisions under uncertainty using four stylized agents: an expected-value maximizer, an expected-utility agent, a boundedly rational satisficer, and a robust minimax-regret agent. It uses only the Python standard library and exports reproducible tables and decision records.

# history_of_decision_science_simulation.py
# Standard-library simulation of historical decision paradigms:
# expected value, expected utility, satisficing, minimax regret,
# noisy choice, robustness, and decision-record output.

from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
import csv
import json
import math
import random
from statistics import mean, pstdev

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
    subjective_probability: float


@dataclass(frozen=True)
class Strategy:
    name: str
    payoffs: tuple[float, ...]


def utility(value: float, risk_aversion: float = 0.016) -> float:
    return 1.0 - math.exp(-risk_aversion * value)


def validate_probabilities(values: list[float], label: str) -> None:
    if not math.isclose(sum(values), 1.0, abs_tol=1e-9):
        raise ValueError(f"{label} must sum to 1. Current sum: {sum(values)}")


def expected_value(strategy: Strategy, probabilities: list[float]) -> float:
    return sum(payoff * probability for payoff, probability in zip(strategy.payoffs, probabilities))


def expected_utility(strategy: Strategy, probabilities: list[float]) -> float:
    return sum(utility(payoff) * probability for payoff, probability in zip(strategy.payoffs, probabilities))


def regret_rows(strategies: list[Strategy], scenarios: list[Scenario]) -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []
    scenario_count = len(scenarios)

    for scenario_index in range(scenario_count):
        best_payoff = max(strategy.payoffs[scenario_index] for strategy in strategies)
        scenario_name = scenarios[scenario_index].name

        for strategy in strategies:
            payoff = strategy.payoffs[scenario_index]
            rows.append({
                "scenario": scenario_name,
                "strategy": strategy.name,
                "payoff": round(payoff, 4),
                "best_payoff": round(best_payoff, 4),
                "regret": round(best_payoff - payoff, 4),
            })

    return rows


def maximum_regret(strategy: Strategy, strategies: list[Strategy], scenarios: list[Scenario]) -> float:
    rows = regret_rows(strategies, scenarios)
    return max(float(row["regret"]) for row in rows if row["strategy"] == strategy.name)


def robustness_share(strategy: Strategy, threshold: float = 40.0) -> float:
    return sum(1 for payoff in strategy.payoffs if payoff >= threshold) / len(strategy.payoffs)


def weighted_scenario_index(scenarios: list[Scenario], rng: random.Random) -> int:
    draw = rng.random()
    cumulative = 0.0
    for index, scenario in enumerate(scenarios):
        cumulative += scenario.probability
        if draw <= cumulative:
            return index
    return len(scenarios) - 1


def choose_expected_value(strategies: list[Strategy], probabilities: list[float]) -> Strategy:
    return max(strategies, key=lambda strategy: expected_value(strategy, probabilities))


def choose_expected_utility(strategies: list[Strategy], probabilities: list[float]) -> Strategy:
    return max(strategies, key=lambda strategy: expected_utility(strategy, probabilities))


def choose_subjective_expected_utility(strategies: list[Strategy], subjective_probabilities: list[float]) -> Strategy:
    return max(strategies, key=lambda strategy: expected_utility(strategy, subjective_probabilities))


def choose_minimax_regret(strategies: list[Strategy], scenarios: list[Scenario]) -> Strategy:
    return min(strategies, key=lambda strategy: maximum_regret(strategy, strategies, scenarios))


def choose_satisficing(
    strategies: list[Strategy],
    scenario_index: int,
    threshold: float = 50.0,
) -> Strategy:
    search_order = ["Aggressive", "Balanced", "Adaptive", "Defensive"]
    lookup = {strategy.name: strategy for strategy in strategies}

    for name in search_order:
        candidate = lookup[name]
        if candidate.payoffs[scenario_index] >= threshold:
            return candidate

    return lookup[search_order[-1]]


def choose_noisy_expected_value(
    strategies: list[Strategy],
    probabilities: list[float],
    rng: random.Random,
    noise_scale: float = 8.0,
) -> Strategy:
    noisy_scores = {
        strategy.name: expected_value(strategy, probabilities) + rng.gauss(0.0, noise_scale)
        for strategy in strategies
    }
    selected_name = max(noisy_scores, key=noisy_scores.get)
    return next(strategy for strategy in strategies if strategy.name == selected_name)


def summarize_strategies(strategies: list[Strategy], scenarios: list[Scenario]) -> list[dict[str, object]]:
    probabilities = [scenario.probability for scenario in scenarios]
    subjective_probabilities = [scenario.subjective_probability for scenario in scenarios]
    regrets = regret_rows(strategies, scenarios)

    rows: list[dict[str, object]] = []

    for strategy in strategies:
        strategy_regrets = [float(row["regret"]) for row in regrets if row["strategy"] == strategy.name]
        rows.append({
            "strategy": strategy.name,
            "expected_value": round(expected_value(strategy, probabilities), 4),
            "expected_utility": round(expected_utility(strategy, probabilities), 6),
            "subjective_expected_utility": round(expected_utility(strategy, subjective_probabilities), 6),
            "minimum_payoff": round(min(strategy.payoffs), 4),
            "maximum_payoff": round(max(strategy.payoffs), 4),
            "payoff_sd": round(pstdev(strategy.payoffs), 4),
            "maximum_regret": round(max(strategy_regrets), 4),
            "average_regret": round(mean(strategy_regrets), 4),
            "robustness_share": round(robustness_share(strategy, threshold=40.0), 4),
            "satisficing_share": round(robustness_share(strategy, threshold=50.0), 4),
        })

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


def simulate(
    strategies: list[Strategy],
    scenarios: list[Scenario],
    trials: int = 1000,
    seed: int = 42,
) -> list[dict[str, object]]:
    rng = random.Random(seed)

    probabilities = [scenario.probability for scenario in scenarios]
    subjective_probabilities = [scenario.subjective_probability for scenario in scenarios]

    validate_probabilities(probabilities, "Objective probabilities")
    validate_probabilities(subjective_probabilities, "Subjective probabilities")

    ev_strategy = choose_expected_value(strategies, probabilities)
    eu_strategy = choose_expected_utility(strategies, probabilities)
    seu_strategy = choose_subjective_expected_utility(strategies, subjective_probabilities)
    robust_strategy = choose_minimax_regret(strategies, scenarios)

    rows: list[dict[str, object]] = []

    for trial in range(1, trials + 1):
        scenario_index = weighted_scenario_index(scenarios, rng)
        scenario = scenarios[scenario_index]

        satisficing_strategy = choose_satisficing(strategies, scenario_index, threshold=50.0)
        noisy_strategy = choose_noisy_expected_value(strategies, probabilities, rng)

        rows.append({
            "trial": trial,
            "scenario": scenario.name,
            "expected_value_strategy": ev_strategy.name,
            "expected_value_payoff": round(ev_strategy.payoffs[scenario_index], 4),
            "expected_utility_strategy": eu_strategy.name,
            "expected_utility_payoff": round(eu_strategy.payoffs[scenario_index], 4),
            "subjective_expected_utility_strategy": seu_strategy.name,
            "subjective_expected_utility_payoff": round(seu_strategy.payoffs[scenario_index], 4),
            "robust_strategy": robust_strategy.name,
            "robust_payoff": round(robust_strategy.payoffs[scenario_index], 4),
            "satisficing_strategy": satisficing_strategy.name,
            "satisficing_payoff": round(satisficing_strategy.payoffs[scenario_index], 4),
            "noisy_expected_value_strategy": noisy_strategy.name,
            "noisy_expected_value_payoff": round(noisy_strategy.payoffs[scenario_index], 4),
        })

    return rows


def summarize_simulation(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    agents = [
        ("Expected Value", "expected_value_payoff"),
        ("Expected Utility", "expected_utility_payoff"),
        ("Subjective Expected Utility", "subjective_expected_utility_payoff"),
        ("Robust Minimax Regret", "robust_payoff"),
        ("Satisficing", "satisficing_payoff"),
        ("Noisy Expected Value", "noisy_expected_value_payoff"),
    ]

    output: list[dict[str, object]] = []

    for agent_name, field in agents:
        values = [float(row[field]) for row in rows]
        output.append({
            "agent": agent_name,
            "average_payoff": round(mean(values), 4),
            "minimum_payoff": round(min(values), 4),
            "maximum_payoff": round(max(values), 4),
            "payoff_sd": round(pstdev(values), 4),
            "loss_frequency": round(sum(1 for value in values if value < 0) / len(values), 4),
            "acceptable_frequency": round(sum(1 for value in values if value >= 40.0) / len(values), 4),
        })

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


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


def write_decision_record(
    path: Path,
    strategy_summary: list[dict[str, object]],
    simulation_summary: list[dict[str, object]],
) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)

    record = {
        "article": "The History of Decision Science",
        "decision_context": "Comparison of historical decision paradigms under uncertainty.",
        "historical_interpretation": "Different eras of decision science emphasize different criteria: expectation, utility, subjective belief, bounded rationality, regret, and robustness.",
        "robust_candidate": strategy_summary[0]["strategy"],
        "strategy_summary": strategy_summary,
        "simulation_summary": simulation_summary,
        "modeling_principles": [
            "Expected value represents early probability-weighted payoff reasoning.",
            "Expected utility represents subjective valuation and risk attitude.",
            "Subjective expected utility represents coherent belief under uncertainty.",
            "Satisficing represents bounded rationality and limited search.",
            "Minimax regret represents robust decision-making under uncertain futures.",
            "Noisy expected value represents judgment under imperfect attention and estimation noise.",
            "Computational models support historical interpretation but do not replace judgment.",
        ],
    }

    path.write_text(json.dumps(record, indent=2), encoding="utf-8")


def main() -> None:
    scenarios = [
        Scenario("Stable Growth", 0.42, 0.30),
        Scenario("Moderate Shock", 0.28, 0.34),
        Scenario("Severe Disruption", 0.18, 0.24),
        Scenario("Institutional Constraint", 0.12, 0.12),
    ]

    strategies = [
        Strategy("Aggressive", (128.0, 50.0, -90.0, -20.0)),
        Strategy("Balanced", (92.0, 68.0, 18.0, 42.0)),
        Strategy("Defensive", (62.0, 58.0, 44.0, 54.0)),
        Strategy("Adaptive", (88.0, 70.0, 36.0, 72.0)),
    ]

    strategy_summary = summarize_strategies(strategies, scenarios)
    regrets = regret_rows(strategies, scenarios)
    simulation_rows = simulate(strategies, scenarios, trials=1000, seed=42)
    simulation_summary = summarize_simulation(simulation_rows)

    write_csv(TABLES / "historical_strategy_summary.csv", strategy_summary)
    write_csv(TABLES / "historical_regret_table.csv", regrets)
    write_csv(TABLES / "historical_simulation_trials.csv", simulation_rows)
    write_csv(TABLES / "historical_simulation_summary.csv", simulation_summary)
    write_decision_record(RECORDS / "history_of_decision_science_record.json", strategy_summary, simulation_summary)

    print("History of decision science workflow complete.")
    print(TABLES / "historical_strategy_summary.csv")
    print(TABLES / "historical_simulation_summary.csv")
    print(RECORDS / "history_of_decision_science_record.json")


if __name__ == "__main__":
    main()

This Python workflow makes the field’s historical layers computationally visible. Expected value, expected utility, subjective expected utility, satisficing, noisy judgment, and minimax regret are not merely abstract historical concepts. They produce different recommendations, different vulnerabilities, and different interpretations of what it means to decide well.

Back to top ↑

GitHub Repository

The companion repository for this article supports reproducible exploration of historical decision paradigms, including expected monetary value, expected utility, subjective probability, Bayesian updating, bounded rationality, satisficing, noisy choice, regret analysis, robustness diagnostics, scenario comparison, and decision-record generation.

articles/history-of-decision-science/
├── python/
│   ├── history_of_decision_science_simulation.py
│   ├── expected_value_historical_baseline.py
│   ├── expected_utility_bernoulli_model.py
│   ├── subjective_probability_savage_model.py
│   ├── bayesian_update_history_example.py
│   ├── bounded_rationality_satisficing.py
│   ├── behavioral_noise_choice_model.py
│   ├── minimax_regret_history.py
│   ├── robustness_historical_paradigms.py
│   ├── decision_record_exporter.py
│   └── run_all_history_workflows.py
├── r/
│   ├── history_of_decision_science_workflow.R
│   ├── expected_utility_history_profiles.R
│   ├── subjective_probability_profiles.R
│   ├── regret_and_robustness_history.R
│   ├── bounded_rationality_summary.R
│   ├── historical_rank_visualization.R
│   └── run_all_history_workflows.R
├── julia/
│   ├── high_performance_historical_regret_scan.jl
│   ├── expected_utility_surface_history.jl
│   └── robust_paradigm_frontier.jl
├── sql/
│   ├── schema_history_of_decision_science.sql
│   ├── historical_traditions.sql
│   ├── paradigms.sql
│   ├── scenarios.sql
│   ├── payoffs.sql
│   ├── regret_results.sql
│   ├── robustness_results.sql
│   └── decision_records.sql
├── rust/
│   └── historical_decision_diagnostics_cli.rs
├── go/
│   └── historical_expected_utility_runner.go
├── cpp/
│   ├── historical_minimax_regret_solver.cpp
│   └── expected_utility_fast_scan.cpp
├── fortran/
│   └── historical_numerical_decision_model.f90
├── c/
│   └── historical_expected_value_core.c
├── docs/
│   ├── article_notes.md
│   ├── modeling_principles.md
│   ├── probability_foundations.md
│   ├── expected_utility_history.md
│   ├── operations_research_history.md
│   ├── bounded_rationality_history.md
│   ├── behavioral_decision_research.md
│   ├── robust_decision_making_history.md
│   ├── responsible_use.md
│   └── assumptions_and_limitations.md
├── data/
│   ├── synthetic_historical_paradigms.csv
│   ├── synthetic_strategy_payoffs.csv
│   ├── synthetic_probability_sets.csv
│   ├── synthetic_behavioral_noise.csv
│   ├── synthetic_regret_matrix.csv
│   └── synthetic_decision_records.csv
├── outputs/
│   ├── README.md
│   ├── figures/
│   ├── tables/
│   └── decision_records/
└── notebooks/
    ├── python_history_of_decision_science_walkthrough.ipynb
    └── r_historical_paradigms_placeholder.ipynb

This repository structure mirrors the article’s historical argument. The python/ folder supports simulation of historical decision agents. The r/ folder supports reproducible paradigm comparison and visualization. The sql/ layer records paradigms, assumptions, scenarios, payoffs, and decision records. The lower-level language scaffolds support efficient expected-value, utility, and regret calculations. The goal is not only to reproduce a model, but to show how different historical conceptions of rationality generate different decision diagnostics.

Back to top ↑

Back to top ↑

Common Pitfalls in Interpreting the Field’s History

The history of decision science is often misunderstood when one tradition is treated as the whole field or when later developments are framed as simple replacements for earlier ones.

The strongest interpretation of the field’s history is cumulative. Decision science did not move from wrong methods to right methods. It expanded its understanding of what decision-making requires.

Back to top ↑

Why the History Still Matters

The history of decision science is not the story of one theory replacing another, but of a field becoming progressively more realistic about what decision-making requires. From probability and expected utility to bounded rationality, behavioral research, systems thinking, and robust planning, the field expanded whenever simpler models proved inadequate to the environments people actually face.

That history explains why decision science remains important today. It offers neither a single algorithm for rationality nor a rejection of formal reasoning. Instead, it provides a structured way to connect mathematics, behavior, institutions, uncertainty, values, computation, and systems. Its historical strength lies in its ability to combine formal rigor with practical judgment.

In a world marked by complexity, strategic interaction, technological acceleration, contested futures, and institutional accountability, that combination is not optional. It is the foundation of serious decision work.

Back to top ↑

Related Articles

• Decision Science
• What Is Decision Science?
• Decision Science vs. Decision Theory
• Why Uncertainty Changes Decision-Making
• Core Principles of Decision Science
• Expected Value and Expected Utility
• Bayesian Decision-Making
• Decision Trees and Structured Choice
• Sensitivity Analysis and Scenario Comparison
• Behavioral Economics
• Systems Modeling
• Robust Decision-Making

Back to top ↑

Further Reading

• Abbas, A.E. and Howard, R.A. (2015) Foundations of Decision Analysis. Harlow: Pearson. Publisher information available at: https://www.pearson.com/en-us/subject-catalog/p/foundations-of-decision-analysis/P200000003532/9780133404180
• Gigerenzer, G. (2007) Gut Feelings: The Intelligence of the Unconscious. New York: Viking. Publisher information available at: https://www.penguinrandomhouse.com/books/294138/gut-feelings-by-gerd-gigerenzer/
• Howard, R.A. and Abbas, A.E. (2023) Foundations of Decision Analysis. Harlow: Pearson. Publisher information 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. Publisher information available at: https://us.macmillan.com/books/9780374533557/thinkingfastandslow
• Knight, F.H. (1921) Risk, Uncertainty, and Profit. Boston, MA: Houghton Mifflin. Archival edition 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.
• Savage, L.J. (1972) The Foundations of Statistics. New York: Dover. Publisher information available at: https://store.doverpublications.com/products/9780486623498
• 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. Publisher information available at: https://www.penguinrandomhouse.com/books/248772/superforecasting-by-philip-tetlock-and-dan-gardner/

Back to top ↑

References

• Abbas, A.E. and Howard, R.A. (2015) Foundations of Decision Analysis. Harlow: Pearson. Available at: https://www.pearson.com/en-us/subject-catalog/p/foundations-of-decision-analysis/P200000003532/9780133404180
• Bernoulli, D. (1954) “Exposition of a New Theory on the Measurement of Risk.” Econometrica, 22(1), pp. 23–36. Available at: https://www.jstor.org/stable/1909829
• Ellsberg, D. (1961) “Risk, Ambiguity, and the Savage Axioms.” Quarterly Journal of Economics, 75(4), pp. 643–669. Stable record available at: https://www.jstor.org/stable/1884324
• 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
• INFORMS (1984) “The Origin of Operational Research.” Operations Research, 32(2), pp. 465–473. Abstract available at: https://pubsonline.informs.org/doi/10.1287/opre.32.2.465
• Kahneman, D. and Tversky, A. (1979) “Prospect Theory: An Analysis of Decision under Risk.” Econometrica, 47(2), pp. 263–291.
• Knight, F.H. (1921) Risk, Uncertainty, and Profit. Boston, MA: Houghton Mifflin. Available at: https://oll.libertyfund.org/titles/knight-risk-uncertainty-and-profit
• Nobel Prize Outreach AB (1978) “The Prize in Economic Sciences 1978 – Press Release.” Available at: https://www.nobelprize.org/prizes/economic-sciences/1978/press-release/
• Nobel Prize Outreach AB (1978) “Herbert A. Simon – Prize Lecture: Rational Decision-Making in Business Organizations.” Available at: https://www.nobelprize.org/prizes/economic-sciences/1978/simon/lecture/
• Raiffa, H. (1968) Decision Analysis: Introductory Lectures on Choices Under Uncertainty. Reading, MA: Addison-Wesley.
• RAND Corporation (2013) “Making Good Decisions Without Predictions.” Available at: https://www.rand.org/pubs/research_briefs/RB9701.html
• RAND Corporation (n.d.) “Decision Making Under Deep Uncertainty.” Available at: https://www.rand.org/global-and-emerging-risks/centers/pardee/dmdu-decision-making-under-deep-uncertainty.html
• RAND Corporation (n.d.) “Robust Decision Making.” Available at: https://www.rand.org/topics/robust-decision-making.html
• Savage, L.J. (1972) The Foundations of Statistics. New York: Dover. Available at: https://store.doverpublications.com/products/9780486623498
• Simon, H.A. (1978) “Rational Decision-Making in Business Organizations.” Nobel Prize lecture, 8 December. Available at: https://www.nobelprize.org/prizes/economic-sciences/1978/simon/lecture/
• Stanford School of Engineering (2014) “Stanford Professor Ron Howard shares honors for pioneering decision analysis.” Available at: https://engineering.stanford.edu/news/stanford-professor-ron-howard-shares-honors-pioneering-decision-analysis
• 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 ↑