;; Mr. Buffet's March Madness Insurance Policy
;; Tim Showalter
;; 23 jan 2014
;; How much did Warren Buffet charge Quicken Loans for the insurance
;; policy for the Quicken Loans $1B challenge?
;; Well, let's start with this: What is the ev (fair premium) of the
;; insurance policy that Berkshire "sold" for the Quicken Loans $1B
;; challenge?
;; After playing with this a bit, making some very generous
;; assumptions about the odds of anyone getting a pick right, the cost
;; of this policy is somewhere between a rounding error on Berkshire's
;; balance sheet and a third of a Superbowl ad.
;; I did this in Lisp because I like the way it does bignums and
;; ratios. Ultimately I changed it to use floating-point. This
;; program can be easily modified not to use floating point (set p to
;; 0, and pass in probabilities as ratios) but it becomes very slow
;; due to the big loop. I suspect there is a simplification of that
;; compounding calculation but I don't know what it is.
;; I have only attempted to optimize this a little, and not very well.
;; It works for me on a recent SBCL release.
;; A more robust exploration would make some assumptions about the
;; brackets, for instance, it is very likely that any given 1-seed
;; will win, but closer to 50-50 that the 8 seed will beat the 9 seed.
;; Quoted odds are 2**63, which is clearly bullshit. That's assuming
;; you can pick no better than 50-50, but it's not that hard to figure
;; out that the '1' seeds win more than that. At that figure, the
;; expected payout of the insurance is less $0.0005.
(defun ev-of-insurance (chance-of-any-game-right
number-of-games
prize
number-of-unique-brackets)
(check-type number-of-games fixnum)
(check-type number-of-unique-brackets fixnum)
(let* ((chance-of-some-guy-hitting-in-isolation
(expt chance-of-any-game-right number-of-games))
(chance-of-correct-bracket
(let ((p 0.0d0))
(loop
for i from 1 to number-of-unique-brackets
do (setf p (+ p
(* (- 1 p)
chance-of-some-guy-hitting-in-isolation))))
p)))
(* prize
chance-of-correct-bracket)))
;; run like this:
(mapcar (lambda (chance)
(list chance
(format nil "~f"
(ev-of-insurance chance 63 500000000 10000000))))
(mapcar (lambda (x) (coerce x 'double-float))
(list .5 .55 .6 .61 .62 .63 .64 .65
.7 .71 .72 .73 .74
.75 .8 .85 .9 .91 .92 .95 .99)))
;; or this (fewer parens in the output)
(mapcar (lambda (chance)
(format nil "chance = ~f EV = ~f" chance
(ev-of-insurance chance 63 500000000 10000000)))
(mapcar (lambda (x) (coerce x 'double-float))
(list .5 .55 .6 .61 .62 .63 .64 .65 .66 .67 .68 .69
.70 .71 .72 .73 .74
.75 .8 .85 .9 .91 .92 .95 .99)))
;; =>
;; ((0.5d0 "0.0005421010862427522")
;; (0.550000011920929d0 "0.21969493037766546")
;; (0.6000000238418579d0 "52.78370157127043")
;; (0.6100000143051147d0 "149.53752443315457")
;; (0.6200000047683716d0 "416.53017832041127")
;; (0.6299999952316284d0 "1141.3633347777104")
;; (0.6399999856948853d0 "3078.267923612577")
;; (0.6499999761581421d0 "8175.360619571965")
;; (0.699999988079071d0 "870497.9092146895")
;; (0.7099999785423279d0 "2124812.9967592317")
;; (0.7200000286102295d0 "5113146.489215795")
;; (0.7300000190734863d0 "12105968.193878852")
;; (0.7400000095367432d0 "28059986.683141798")
;; (0.75d0 "62942149.90757288")
;; (0.800000011920929d0 "499804418.77547836")
;; (0.8500000238418579d0 "499999999.9992238")
;; (0.8999999761581421d0 "499999999.99997884")
;; (0.9100000262260437d0 "499999999.99998945")
;; (0.9200000166893005d0 "499999999.99999475")
;; (0.949999988079071d0 "499999999.99999934")
;; (0.9900000095367432d0 "500000000.0"))
;; Later research indicated that last year, in about 8 million
;; brackets entered on ESPN, 5 people got 30 games right out of the
;; first round of 32. So let's assume Q^30 = 5/(8 * 10^7) (I believe
;; this is pessimistic, and clearly a bullshit calculation.)
;; http://www.wolframalpha.com/input/?i=Q^30+%3D+5%2F%288+*+10^7%29
;; indicates Q is about 0.57526.
;; (ev-of-insurance 0.576d0 63 500000000 10000000)
;; => 4.032612186755561d0
;; (ev-of-insurance 0.57526d0 63 500000000 10000000)
;; => 3.7188884353487865d0
;; FOUR BUCKS.
;; We can assume every sports bettor worth his salt will enter the
;; challenge, and we can expect a possible winner to be better than
;; average; but even assuming everybody could pick 64% correctly means
;; we'd get an EV of around $3100.
;; Back to the original question: How much was the policy? I don't
;; know. Given that Berkshire openly backed the promotion, I assume
;; that it was sort of as a favor to Quicken Loan's CEO or something.
;; It's just a nice thing to be associated with. I am also sure that
;; money changed hands. But I'm guessing, not that much. QL is
;; paying $100K to the 20 best brackets, anyway, so obviously they
;; have a little left in the promotion budget.
;; I later read another article here that claimed the premium should be
;; about $20M: http://today.duke.edu/2014/01/millerodds
;; but that's assuming a 67 game bracket. Here are my computations for
;; a 67-game bracket:
;; CL-USER> (mapcar (lambda (chance)
;; (list chance
;; (format nil "~f"
;; (ev-of-insurance chance 67 500000000 10000000))))
;; (mapcar (lambda (x) (coerce x 'double-float))
;; (list .5 .55 .57526d0 .6 .61 .62 .63 .64 .65
;; .7 .71 .72 .73 .74
;; .75 .8 .85 .9 .91 .92 .95 .99)))
;; ((0.5d0 "0.000033881317890172014") (0.550000011920929d0 "0.020103460972790026")
;; (0.57526d0 "0.40725822026846664") (0.6000000238418579d0 "6.840769125272244")
;; (0.6100000143051147d0 "20.70473247795121")
;; (0.6200000047683716d0 "61.547922431870624")
;; (0.6299999952316284d0 "179.79868844049494")
;; (0.6399999856948853d0 "516.4489354800111")
;; (0.6499999761581421d0 "1459.362553603402")
;; (0.699999988079071d0 "209144.93114499355")
;; (0.7099999785423279d0 "540808.505219475")
;; (0.7200000286102295d0 "1379268.1998981668")
;; (0.7300000190734863d0 "3468101.8575161006")
;; (0.7400000095367432d0 "8584998.671514748") (0.75d0 "20838356.60545025")
;; (0.800000011920929d0 "479899829.7578061")
;; (0.8500000238418579d0 "499999999.99851316")
;; (0.8999999761581421d0 "499999999.99996775")
;; (0.9100000262260437d0 "499999999.9999846")
;; (0.9200000166893005d0 "499999999.9999926")
;; (0.949999988079071d0 "499999999.99999917")
;; (0.9900000095367432d0 "500000000.0"))