Priority decisions

Last time, we introduced the basic setup of decision theory and examined the dominance decision rule. We also emphasized that the dominance decision rule is “weak” because it applies in very general settings with limited information to go on.

This time, we’ll look at other decision rules that apply in that very general setting. They’re still decisions under ignorance—no probabilities associated with states of the world—and outcomes are still measured only on an ordinal scale.

Maximin

The first such decision rule is maximin.

Prose

Maximin suggests that in any decision scenario, we look to the worst outcome that may come to pass under each plan of action. We should then pick the action which has the best such outcome. That is, we pick the action with the best worst case—maximize our minimum.

Example

You have the choice of two alternative routes to work. In good conditions, the first route takes 10 minutes and the second route 5 minutes. But the second route is prone to traffic and on bad days takes 20 minutes while the first route still takes 10 minutes.

With a scenario like this, the maximin rule demands that you take the first route since its worst case is only 10 minutes while the second route’s worst case is 20 minutes.

Interactive

If the above description isn’t sufficient, try poking around with this interactive analysis (Note that “better than” in this case means later in ASCIIbetical order—later letters are better than earlier letters). The analysis will update whenever you stop editing text and defocus the text area.

We see that with the default input table, Actions 2 and 3 beat Action 1 since the worst case of ‘b’ is preferable to the worst case of ‘a’. Actions 2 and 3 beat each other since they have the same worst case—‘b’—and we’re using a weak maximin here.

Code

We can also explain maximin with its implementing source code:

maximin :: forall cell. Ord cell => PairOfRows cell -> Boolean
maximin rows = Foldable1.minimum row1 Prelude.>= Foldable1.minimum row2
  where
    Tuple row1 row2 = unzipNeMultiSet rows

Again, maximin applies in very general settings because the only constraint we must satisfy is that cells are orderable¹.

Math

We can also describe maximin \(\preccurlyeq_{MaMi}\) in symbols:

\[a_i \preccurlyeq_{MaMi} a_j \leftrightarrow \min_{s \in S} v(a_i, s) \leq \min_{s \in S} v(a_j, s)\]

where \(a_i\) and \(a_j\) represent the ith and jth actions, \(s\) is a particular state of the world from the set \(S\) of all states, and \(v : A \times S \to V\) is a function mapping an action in a particular state of the world to an element in the total order order of values \(V\).

Maximax

The second decision rule we’ll look it maximax. It’s considerably more optimistic than maximin.

Prose

Maximax suggests that in any decision scenario, we look to the best outcome that may come to pass under each plan of action. We should then pick the action which has the best such outcome. That is, we pick the action with the best best case—maximize our maximum.

Example

Suppose you’re choosing between routes to work again:

With a scenario like this, the maximax rule demands that you take the second route since its best case is only 5 minutes while the first route’s best case is 10 minutes.

Interactive

If the above description isn’t sufficient, try poking around with this interactive analysis (Note that “better than” in this case means later in ASCIIbetical order—later letters are better than earlier letters). The analysis will update whenever you stop editing text and defocus the text area.

We see that with the default input table, Actions 1 and 3 beat Action 2 since the best case of ‘z’ is preferable to the best case of ‘y’. Actions 1 and 3 beat each other since they have the same best case—‘z’—and we’re using a weak maximax here.

Code

We can also explain maximax with its implementing source code:

maximax :: forall cell. Ord cell => PairOfRows cell -> Boolean
maximax rows = Foldable1.maximum row1 Prelude.>= Foldable1.maximum row2
  where
    Tuple row1 row2 = unzipNeMultiSet rows

Again, maximax applies in very general settings because the only constraint we must satisfy is that cells are orderable.

Math

We can also describe maximax \(\preccurlyeq_{MaMa}\) in symbols:

\[a_i \preccurlyeq_{MaMa} a_j \leftrightarrow \max_{s \in S} v(a_i, s) \leq \max_{s \in S} v(a_j, s)\]

where \(a_i\) and \(a_j\) represent the ith and jth actions, \(s\) is a particular state of the world from the set \(S\) of all states, and \(v : A \times S \to V\) is a function mapping an action in a particular state of the world to an element in the total order order of values \(V\).

Leximin

The final decision rule we’ll look at today is leximin.

Prose

We can think of leximin as maximin with a tiebreaking procedure. In leximin, if the worst outcomes are equal, we then look to the second worst outcomes and prefer whichever action has the better second worst outcome. This tiebreaking procedure continues all the way up the ordered list of worst-to-best outcomes per action and only declares indifference between the actions if outcomes are the same at each step.

Alternatively, we can think of leximin as the general procedure and maximin and maximax as special cases of it. Leximin looks at the whole sorted list of outcomes for each action while maximin and maximax each only look at one end of the list.

Example

Suppose you’re choosing between routes to work again:

Route 2 is preferable because the two routes tie in the worst case—20 minutes— but route 2’s 8 minutes is a better a second worst case than route 1’s 12 minutes.

Interactive

If the above description isn’t sufficient, try poking around with this interactive analysis (Note that “better than” in this case means later in ASCIIbetical order—later letters are better than earlier letters). The analysis will update whenever you stop editing text and defocus the text area.

We see that with the default input table, Actions 2 and 3 beat Action 1 since the worst case of ‘b’ is preferable to the worse case of ‘a’. Actions 3 beats Action 2 since the second worst case of ‘d’ is preferable to the second worst case ‘c’

Code

We can also explain leximin with its implementing source code:

leximin :: forall cell. Ord cell => PairOfRows cell -> Boolean
leximin rows =
    fromMaybe true <<< List.head <<< NonEmpty.mapMaybe keepNonEq $
    NonEmpty.zipWith compare (NonEmpty.sort row1) (NonEmpty.sort row2)
  where
    Tuple row1 row2 = unzipNeMultiSet rows
    keepNonEq GT = Just true
    keepNonEq LT = Just false
    keepNonEq EQ = Nothing

Again, leximin applies in very general settings because the only constraint we must satisfy is that cells are orderable.