Everything, in one place

• “Normative” = it prescribes what an ideal rational agent ought to do — not what real people do (that is Lecture 5).
• Three ingredients: a set of actions, the possible states/outcomes, and a utility over those outcomes.
• Two regimes: decision under risk (probabilities known → maximise expected utility) vs decision under ignorance (no probabilities → apply a rule).
• It is the yardstick the rest of the course measures everything against.

🎯 In the examAlways first decide which regime you are in — risk (have probabilities) or ignorance (don’t) — because it picks the tool.

• Maximin (Wald): maximise the worst case — pessimistic / cautious.
• Maximax: maximise the best case — optimistic.
• Hurwicz: blend worst and best with an optimism coefficient α.
• Minimax-regret (Savage): minimise the largest regret (gap from the best you could have done in each state).
• Laplace / insufficient reason: assume all states equally likely, then maximise expected utility.

ExampleInvesting with no idea of the odds: maximin picks the option whose worst outcome is least bad.

🎯 In the examBe able to compute each rule from a payoff table and state the attitude it encodes.

• Three node types: chance (ovals = random variables), decision (rectangles = your choices), utility (diamond = the objective).
• Solving it = pick the decision(s) that maximise expected utility given the evidence.
• It directly unifies L1 (expected utility) with L2’s compact representation.
• It is the basis of the “probabilistic” model paradigm catalogued in Lecture 6.

🎯 In the examName the three node types and that the output is the EU-maximising decision.

• #P is the counting analogue of NP: not “is there a solution?” but “how many?” — believed even harder than NP-complete.
• Exact inference is only efficient for special structures (e.g. trees / low treewidth).
• So in practice we use approximate inference: sampling (MCMC), variational methods, loopy belief propagation.
• The lesson generalises: a good representation does not guarantee cheap computation — a recurring DSS theme.

🎯 In the examKey word is #P-hard; the takeaway is “use approximate inference”. (Complexity was flagged as lighter for the exam.)

• Key shift from L1: the outcome of your action depends on what others do, so you must reason about their reasoning.
• Non-cooperative game theory: players cannot make binding agreements; each maximises its own payoff.
• Central questions: what is a “solution” to a game? (Nash) and can players do better by coordinating? (correlated equilibrium).
• Games can be zero-sum (pure competition) or general-sum (mixed motives, like the prisoner’s dilemma).

🎯 In the examThe course focuses on non-cooperative games with the Nash equilibrium as the solution concept.

• Also called strategic form; it assumes simultaneous moves (neither sees the other’s choice first).
• Contrast with extensive form (a game tree) used for sequential moves.
• From the matrix you find dominant strategies, best responses, and equilibria.
• A strategy may be pure (one action) or mixed (a probability distribution over actions).

ExampleThe prisoner’s dilemma is a 2×2 matrix where (Defect, Defect) is the equilibrium even though (Cooperate, Cooperate) is better for both.

• “Unilateral”: hold the others fixed — if no single player gains by deviating alone, it is an equilibrium.
• Existence (Nash’s theorem): every finite game has at least one equilibrium, possibly in mixed strategies.
• It need not be unique, Pareto-efficient, or “fair” — the prisoner’s dilemma equilibrium is worse for both than cooperating.
• Interpretation: a self-enforcing convention / fixed point of mutual best response — not necessarily a prediction of real behaviour.
• Computing one is generally hard (PPAD-complete in general games).

ExamplePrisoner’s dilemma → (Defect, Defect): neither prisoner gains by switching alone, though both prefer (Cooperate, Cooperate).

🎯 In the examThe prof’s verbatim prompt: “define a Nash equilibrium and discuss its interpretation.” Hit mutual best response · always exists (maybe mixed) · not always efficient.

• A pure strategy is the special case that puts probability 1 on a single action.
• In a mixed equilibrium each player is indifferent among the actions they randomise over — that indifference is what makes it stable.
• Why needed: games like rock-paper-scissors or matching pennies have no pure-strategy equilibrium.
• Connects to L4’s stochastic policies and to the adversarial dynamics of GAN training mentioned in lecture.

🎯 In the examExplain why mixed strategies are needed (unpredictability) and that they guarantee existence.

• A trusted “mediator” privately recommends an action to each player; following it is a best response if everyone else follows too.
• Every Nash equilibrium is a correlated equilibrium, but not vice-versa — the set is strictly larger.
• It can achieve expected payoffs that beat every Nash equilibrium.
• It is computationally easier to find than Nash (it is a linear program).

ExampleTraffic light: given your light colour you have no incentive to deviate, and collisions are avoided.

• The knowledge spectrum: know the model → plan with dynamic programming · no model → learn with reinforcement learning · have a simulator → search with MCTS.
• A policy π maps each state to an action; the goal is the policy maximising expected discounted return.
• The discount γ trades immediate vs future reward and keeps infinite-horizon sums finite.
• Everything in the lecture hinges on the Bellman optimality condition.

🎯 In the examThe prof said he will NOT ask for formulas here — only intuition (e.g. “explain Bellman optimality in intuitive terms”).

• Value iteration: repeatedly apply the Bellman update to V until it stops changing, then read off the greedy policy.
• Policy iteration: alternate evaluating the current policy and improving it greedily — fewer but heavier steps.
• Defining assumption: you must KNOW P and R (the full model).
• Guaranteed to converge to the optimal policy for a finite discounted MDP.

ExampleThe lesson’s robot corridor converges to V(1)=5.39, V(2)=7.1, V(3)=9 with policy “always go right”.

• Model-free: the agent never builds P explicitly; it learns values directly from experience tuples (s, a, r, s′).
• Q-learning nudges Q(s,a) toward r + γ·maxₐ′ Q(s′,a′) — a sampled Bellman update.
• Exploration vs exploitation: you must try new actions to learn but exploit known-good ones to score (e.g. ε-greedy).
• Common distinction: off-policy (Q-learning) vs on-policy (SARSA).

🎯 In the examKey contrast with DP: RL has no model and learns from interaction.

• Four steps per iteration: Selection → Expansion → Simulation (roll-out) → Backpropagation.
• UCB balances trying under-explored moves vs exploiting moves that look good (the explore/exploit theme again).
• Needs a generative model / simulator, not the full probability tables — a middle ground between DP and RL.
• Powers AlphaGo / AlphaZero when paired with learned value and policy networks.

🎯 In the examBe able to name the four steps and say what UCB is for.

• Normative models (decision theory, game theory, MDPs/RL) say how agents should decide — enough only if systems acted in isolation.
• But a DSS’s recommendations are interpreted by humans who may ignore or misinterpret them and have cognitive limits.
• So a DSS must account for not just the optimal decision but actual human decision-making behaviour.
• Behavioral decision theory is far less structured than normative theory — a set of important ideas, not one clean axiom system.

🎯 In the examFrame the normative→descriptive pivot — it is the conceptual hinge of the whole syllabus.

• Preference reversal: people choose A over B yet price B above A → no single stable utility U fits both tasks (preferences aren’t representation-invariant).
• Allais paradox: typical choices (A≻B, D≻C) violate the independence axiom — preferences shouldn’t depend on a shared/irrelevant alternative.
• Ellsberg paradox: people prefer the urn with known proportions → they separate risk (known probabilities) from ambiguity (unknown) and are ambiguity-averse.
• Two readings: humans are irrational, or the classical rationality assumptions are too strong — either way it reshapes DSS design.

ExampleEllsberg: bet on “black” then on “red” — most people pick the 49/51 known urn both times, which is internally inconsistent.

🎯 In the examName the three violations and what each breaks; stress risk-vs-ambiguity for Ellsberg.

• Satisficing (Simon): pick the first action whose utility clears an aspiration level θ — early stopping; depends on the order of actions.
• Take-the-best: evaluate cues in order, stop at the first cue that discriminates — depends on the order of cues.
• Recognition heuristic: if you recognise one option and not the other, choose the recognised one (e.g. infer the larger city by name recognition).
• Elimination-by-aspects (Tversky): pick a cue by importance, eliminate options that fail it, repeat — sequential filtering.

🎯 In the examName the four rules and each one’s distinguishing feature (satisficing = order of actions; take-the-best = order of cues).

• Judgement under uncertainty: availability, representativeness, anchoring, over/optimism bias.
• Probabilistic reasoning: base-rate neglect, conjunction fallacy, gambler’s fallacy, confirmation, illusion of control.
• Memory & attention: hindsight, salience, recency, the framing effect, selective perception.
• Temporal: present bias, hyperbolic discounting, status-quo bias, sunk-cost fallacy, planning fallacy.
• Social/attribution: attribution error, in-group, authority, halo, self-serving. Decision/choice: loss aversion, endowment, decoy, preference reversal, ambiguity aversion.

🎯 In the examName the six categories; for any bias, define it + give an example (the define→apply pattern).

• Four defining features: sequential information search, limited cue integration, early stopping, no global optimisation.
• Ecological rationality is the criterion; fast-and-frugal heuristics are the mechanisms (take-the-best, recognition are examples).
• An FFT is a decision tree with sequential binary cue checks and a possible exit at every node — decide after inspecting only a subset of cues.
• Medical triage: chest pain? → admit; else abnormal ECG? → admit; else high BP? → medium risk; else discharge — no probabilistic aggregation.

🎯 In the examList the four fast-and-frugal properties and describe an FFT (early exit, only a subset of cues).

• NDM shifts focus from environment structure to real-world expert behaviour under time pressure.
• How do experts decide well without optimisation? Answer: recognition + experience + mental simulation.
• RPD model: (1) recognise a familiar situation → (2) retrieve a plausible action → (3) mentally simulate its consequences → (4) execute if satisfactory.
• Options are evaluated sequentially, not optimised simultaneously — so RPD is ecological and connects to satisficing.

🎯 In the examGive the four RPD steps and note it is sequential/satisficing-like, not optimisation; name Klein.

• Data subsystem: stores and serves the raw inputs/observations.
• Knowledge subsystem: domain rules, constraints and expert knowledge.
• Model subsystem: the reasoning/computation engine — where the L1–L5 paradigms live.
• User interface: how recommendations and their rationale are communicated — critical for trust and usability.
• Modularity payoff: you can swap the model without rebuilding the data layer or the UI.

🎯 In the examList the four components and the “separate representation from computation” principle.

• Knowledge-based: explicit rules / expert systems — transparent but brittle.
• Model-driven: optimisation and decision-theoretic models (L1).
• Probabilistic: Bayesian / decision networks (L2).
• Learning: machine-learning models fit from data; Sequential: MDP/RL planners (L4); plus hybrids.
• Trade-offs everywhere: accuracy vs transparency vs data needs vs robustness — no single best choice.

🎯 In the examMap each paradigm back to its lecture and note the accuracy/transparency trade-off.

• Trust calibration: ideally reliance tracks actual reliability — trust the system when it’s right, override it when it’s wrong.
• Over-reliance / automation bias: blindly following the system, including its errors.
• Under-reliance / algorithm aversion: ignoring a system that is actually better than you.
• Design levers: transparency, explanations, communicating uncertainty, and managing cognitive load and framing.
• This sets up Lecture 7, where trust and reliance become things you must measure.

🎯 In the examDefine trust calibration and name the two failure modes (over- and under-reliance).

• Why it’s hard: it’s socio-technical (a human+model team), outcome vs process, and inherently multi-dimensional.
• Predictive metrics (accuracy, etc.) are necessary but far from sufficient.
• You must also check calibration, cost/utility (net benefit), fairness, robustness to shift, explainability, usability and adoption.
• And the human-DSS interaction itself — the team can be worse than either part alone.

🎯 In the examLead with “good DSS ≠ good predictor” and enumerate the extra evaluation dimensions.

• Calibration vs discrimination: a model can rank cases well (high AUC) yet output badly-scaled probabilities.
• Reliability diagram: plot predicted vs observed frequency; on the diagonal = well-calibrated.
• ROC curve: true-positive vs false-positive rate across all thresholds; AUC summarises it threshold-free.
• Net benefit / decision-curve analysis turns a threshold into expected utility by weighing false-positive vs false-negative costs — the utility thread from L1.

🎯 In the examDistinguish calibration (probabilities honest) from discrimination (ranking / AUC).

• Distribution shift: covariate shift (inputs change), label shift (base rates change), concept shift (the input→output relation changes).
• Robustness / OOD: behaviour on inputs unlike the training data, and whether it fails gracefully.
• Fairness criteria — demographic parity, equalized odds, calibration-within-groups — are provably incompatible in general; you cannot satisfy all at once.
• Explainability: explanations must be faithful and actually understood — perceived understanding ≠ real understanding.

🎯 In the examName the three shift types and note that fairness criteria are mutually incompatible.

• Complementarity is not automatic — a strong model + a human can underperform either one solo.
• Trust (an attitude) ≠ reliance (a behaviour) ≠ agreement (did they follow it this time).
• Appropriate reliance = following when the system is right and overriding when it is wrong (the calibrated trust from L6).
• Methods: RCTs, A/B tests, simulation studies, longitudinal field studies; plus usability (e.g. SUS) and adoption.

🎯 In the examStress “the team can be worse than either alone” and the trust / reliance / agreement distinctions.