Can medical research be justified?


I investigate the cost-effectiveness of medical research, using methods based on Lichtenburg, Murphy and Topel, and compare this to other charities. I find that the returns on investment in medical research are significantly lower than comparable investments in existing charities.


People who study technology are somewhat spoiled when it comes to returns on research investments. The number of transistors we can fit on a chip has roughly doubled every year for the last 50 years - if life expectancy had kept up, people born today would expect to live for about $6*10^{15}$ years (that's a six followed by 15 zeros). To put it mildly, medical research hasn't quite kept up that pace. What's worse is that we're spending tons of money to keep up this less-than-awesome advancement.

Red line is NIH funding and black is the percentage change in life expectancy. All prices in 2010 dollar equivalents. We're spending more and more on medical research without seeing increasing returns.

So it's reasonable for us to ask if there isn't some way of investing our money more wisely when it comes to medicine. Sendhil Mullainathan has an excellent talk arguing that the type of research we need is not: "What drug will cure this disease?" but "How can we get people to use existing drugs to cure their diseases?" There are some interesting results like Giving Everyone the Health of the Educated and The health impact of resolving racial disparities which suggest that changes in social structure may be more effective than medical research itself.

Now, how do the benefits of research into new drugs stack up? I found a paper by Lichtenberg which discusses the role of pharmaceutical innovation in mortality reduction. A more general paper by Murphy and Topel provide a framework that I'll reuse here.

Essentially, we assume that all increases in health are due to medical research, and that medical research takes 10 years from when it's done to when it affects the world. For example, the health increases from 1990-2000 were the result of research done during the 80s.

A discount rate of 3% per year is used for both costs and benefits. A critical point is that they only considers fixed costs of research, ignoring the costs of treatment itself. (e.g. a treatment which costs a dollar is considered equivalent to a treatment which costs $1,000,000.) I include both costs here.

A few points: The benefits of medical research are measured in QALYs, and the cost is dollars, which gives us something called an ICER. You may remember ICERs as "the thing which Sarah Palin called 'Death Panels'." If you dislike putting a price tag on people's lives, you won't like the rest of this article.


The formula I use is as follows: let $r_t$ be the cost of researching treatment $t$, and $v_t$ be the increased marginal cost of creating the treatment and $p_t$ the number of people who use the treatment. So any treatment $t$ costs $r_t + v_t p_t$ - note that it's entirely possible for the research cost to be negative, assuming the decreased variable cost offsets the increased fixed cost.

To find the sum $\sum_t r_t + v_t p_t$ we can break it into the research cost, which is just the amount spent on research, and the change in variable cost, which is the change in medical expenditures per person multiplied by the total number of people. To prevent a "change in cost" occurring due to population change, the total number of people is defined as the population of the US at the end of the time period.


The benefit is similarly defined by the product of the change in QALYs $q$ with the population $p$. We need to project it forward, so the total benefit is $\sum_{t=0}^{\infty}(.97^t)qp_t$, using our 3% discount rate. To avoid double-counting people, I actually use the formula $qp_0+\sum_{t=1}^{\infty}(.97^t)qb_t$ where $b_t$ is the number of people born in year $t$.

Something to keep in mind is that the benefits of medical research apply not just to everyone who is currently alive, but to everyone who will ever live. So even small advances in life expectancy result in huge benefits (as measured here).


From 1985 to 1994 the US spent about two trillion dollars on medical research (both public and private) and from 1995 to 2005 QALE increased by .7 years, for total ratio of $7,317 per added QALY.

So is that good?

The World Bank and WHO collectively publish a report entitled Disease Control Priorities. Based on this data, and studies performed by charities themselves, an organization called Give Well evaluates which charities and methods are effective. Unfortunately, they use a measure related to QALY but not identical: disability-adjusted life years. Nonetheless, we can get a rough measure of how effective medical research is from their criteria:

We feel that a program can be considered extremely cost-effective if estimates put it in the range of $100 per disability-adjusted life-year (DALY) averted, $50 per life-year significantly changed, or $1000 per life significantly changed. - Give Well on Cost Effectiveness

To put it mildly, $7,317 is slightly larger than $100, giving us a fairly firm answer that no, medical research isn't a good way to spend our money.


Murphy and Topel do a pretty good job of discussing the limitations of this method, so I'll just add that my calculated ICER for medical research is more than two orders of magnitude worse than the best charity, so it's unlikely that minor changes will affect the conclusion.

I hope this article helps inform your decision when a local university requests government money to expand its research program, or you're torn between donating to Race for the Cure and Village Reach.

References / Data

Probably the simplest way to see what I did is to check out the github repo - if you can read R, readYear.r should be able to explain pretty much everything. The function estimates will return the value I gave here.

I wrote down the sources of all the data I used in that R file, but here's another list:


Please don't hesitate to contact me with questions or concerns.

How I Figured out the Y Combinator

The Y Combinator is among the most famous functions in theoretical computer science, which is quite ironic given that it's anonymous (and only really useful because it's anonymous). There's even a massive venture capital firm that took its name. And - somewhat unusually for theoretical CS constructs - it's quite useful.

There are no shortage of tutorials describing how it works, but I couldn't find many which worked through an example. So here's my go at it.

Here's a definition of the combinator that you've probably seen before:

Let's roll it out to see what happens when we actually use it:

So basically, what the Y combinator does is apply a function with itself an infinite number of times. That's already remarkable, because it essentially allows for an infinite amount of recursion with only anonymous functions.

In order to really make it useful though, we need to create an analogy to convergent sequences like $1/2, 1/4, 1/8, \dots$.

A functional equivalent in haskell is something like:
f g x = 1/2 * (g x)
This just uses recursion to generate the next term in the sequence. We can try it out:
Prelude> f id 1
Prelude> f (f id) 1
Prelude> f (f (f id)) 1
The sequence f, f(f), f(f(f)), ... is analogous to the sequence $1/2, 1/4,\dots$ and so it converges to $f^\infty(x) = 0$. To generate an infinite application of f with itself, we can use a fixed point operator:
Y f = (\x -> f (x x)) (\x -> f (x x))
    = f $ (\x -> f (x x)) (\x -> f $ x x)
    = f $ f $ (\x -> f $ x x) (\x -> f $ x x)
    = f $ f $ f $ (\x -> f $ x x) (\x -> f $ x x)
    = f $ f $ f $ f $ (\x -> f $ x x) (\x -> f $ x x)
If we try to use this on our specific $f$ though, Haskell will hang, since, well, it takes an infinite amount of time to converge.

The only kind of convergent sequences that we can use in the "real world" are those which converge in a finite amount of time. No article about functional programming would be complete without a factorial implementation, so here's an example which is readily convergent:
fact g x = if x == 1 then 1 
    else x * (g (x-1)) 
Two examples which give us insight:
Prelude> fact undefined 1
Prelude> fact undefined 2
*** Exception: Prelude.undefined
The function $fact(undefined)$ looks like the following:
if x == 1 then 1
else x * (undefined (x-1))
Since Haskell is lazy, the else branch is never evaluated if x = 1, so we don't need to worry about whether the else is well-defined. It's only when we try to call $fact(2)$ that we're going to get an error.

We can consider the sequence $f(\perp), f\left(f(\perp)\right), f\left(f\left(f(\perp)\right)\right), \dots$. ($\perp$ being the formal way of saying "undefined".) In code, this looks something like:
if x == 1 then 1
else x * (
  if x-1 == 1 then 1
  else (x-1) * (
    if x-2 == 1 then 1
    else (x-2) * (
The $n$th term in this sequence has $n$ of these else clauses. As $n$ goes to infinity, the function approaches the real factorial function, as it has fewer and fewer undefined segments. So we can say that this sequence of functions "converges" to the factorial function.

And the key point is that we only need as many function applications as we need recursive calls, i.e. $fact(n)$ needs only $n$ applications of $fact$ as an input - the $n+1$th can all be undefined. So even though this sequence takes an infinite amount of time to converge, the approximation is "good enough" for finite $n$.

To come full circle: in order to make our approximation arbitrarily correct, we need an arbitrary number of function applications as an input. And this is of course what $fix$ does.

Here is another usage which might make more sense: The idea is that we have an infinite list of functions to apply, and when we need a new one we just pop one off. Which just gives us the arbitrary number of function applications that we need.

To summarize:
  • The Y combinator is just a higher-order function which applies functions to themselves
  • By applying functions to themselves, we get a sequence which converges to the "normal" recursive function.
  • So the Y combinator (as well as any fixed-point operator) can create an "arbitrarily good" approximation of a recursive function.

Toggle arbitrary attributes in jQuery

jQuery has a toggle function, which toggles whether an element is visible or not, as well as toggleClass, which toggles whether an element has a class. But I frequently want to toggle other attributes, particularly the title. This plugin lets you do that.

Booth's multiplication algorithm in Python

I had difficulty finding a readable implementation of Booth's algorithm; hopefully this will prove useful to others.