Game Matrices

; A payoff matrix as a function from (row, col) to (p1, p2)
; Matching Pennies: P1 wins when both choose the same side

(define (matching-pennies row col)
  (cond ((and (eq? row 'H) (eq? col 'H)) '(1 -1))
        ((and (eq? row 'H) (eq? col 'T)) '(-1 1))
        ((and (eq? row 'T) (eq? col 'H)) '(-1 1))
        ((and (eq? row 'T) (eq? col 'T)) '(1 -1))))

; Read the matrix: for each combination, show the payoff vector
(for-each
  (lambda (row)
    (for-each
      (lambda (col)
        (display row) (display ",")
        (display col) (display " -> ")
        (display (matching-pennies row col))
        (display "  "))
      '(H T))
    (newline))
  '(H T))

; A 3x3 game matrix
; Player 1: A, B, C (rows)
; Player 2: X, Y, Z (columns)

(define matrix
  '(((1 2)  (0 4)  (3 1))
    ((2 1)  (1 3)  (0 0))
    ((0 3)  (2 2)  (1 1))))

(define rows '(A B C))
(define cols '(X Y Z))

(define (lookup r c)
  (list-ref (list-ref matrix r) c))

; Display as a table
(display "     X      Y      Z") (newline)
(let loop ((i 0))
  (if (< i 3)
    (begin (display (list-ref rows i)) (display "  ")
      (let col-loop ((j 0))
        (if (< j 3)
          (begin (display (lookup i j)) (display "  ")
                 (col-loop (+ j 1)))))
      (newline)
      (loop (+ i 1)))))

; What does P1 get if P1 plays B and P2 plays Y?
(newline)
(display "P1 plays B, P2 plays Y -> ")
(display (lookup 1 1))
; (1 3) means P1 gets 1, P2 gets 3

; Best response: scan a column (or row) for the best payoff

; P1 best response to column j: maximize first element of payoff
(define (p1-best-response matrix col-idx)
  (let loop ((row 0) (best-row 0)
             (best-val (car (lookup 0 col-idx))))
    (if (>= row (length matrix))
        (list-ref rows best-row)
        (let ((val (car (lookup row col-idx))))
          (if (> val best-val)
              (loop (+ row 1) row val)
              (loop (+ row 1) best-row best-val))))))

; P2 best response to row i: maximize second element of payoff
(define (p2-best-response matrix row-idx)
  (let ((row-data (list-ref matrix row-idx)))
    (let loop ((col 0) (best-col 0)
               (best-val (cadr (car row-data))))
      (if (>= col (length row-data))
          (list-ref cols best-col)
          (let ((val (cadr (list-ref row-data col))))
            (if (> val best-val)
                (loop (+ col 1) col val)
                (loop (+ col 1) best-col best-val)))))))

(display "P1 best response to X: ")
(display (p1-best-response matrix 0)) (newline)
(display "P1 best response to Y: ")
(display (p1-best-response matrix 1)) (newline)
(display "P2 best response to A: ")
(display (p2-best-response matrix 0)) (newline)
(display "P2 best response to B: ")
(display (p2-best-response matrix 1))