https://forum.effectivealtruism.org/posts/cXWAJPipxg5dMxfx8/the-extreme-cost-effectiveness-of-cell-based-meat-r-and-d

in the case where there is no discounting and there are funders other than us, we need to come up with some way to compare different interventions.

assume there are two projects, X and Y, with their own cost, benefit, and outside funding.
let's say we have a fixed budget B

to avoid the problems with stuff going to infinity,
we can seek to minimize the area in the graph of total utility vs. time representing the utility we're missing out on while both projects aren't done
this would be U_X*t_X + U_Y*t_Y

assuming, for now, that neither project is cheap enough for us to fund
we can either fund X and have
t_X = (C_X - B) / F_X
t_Y = C_Y / F_Y

or fund Y and have
t_X = C_X / F_X 
t_Y = (C_Y - B) / F_Y

and we should pick X or Y depending on which of the following is smaller:
U_X*((C_X - B) / F_X) + U_Y*(C_Y / F_Y)
U_X*(C_X / F_X) + U_Y*((C_Y - B) / F_Y)

the advantage of funding X over funding Y would be
(U_X*(C_X / F_X) + U_Y*((C_Y - B) / F_Y)) - (U_X*((C_X - B) / F_X) + U_Y*(C_Y / F_Y))

and i'm going take sympy at its word that this simplifies to
-B*U_Y/F_Y + B*U_X/F_X

so we should fund whatever has higher U/F
and in this case the utility is proportional to our budget so i think it makes sense to think of U/F as being a utility per dollar that can be compared to other interventions


if we have enough budget to fully fund either project and use the remaining budget for the other project,
we can have
t_X = 0
t_Y = (C_Y - (B - C_X)) / F_Y
or
t_X = (C_X - (B - C_Y)) / F_X
t_Y = 0

which if we do the same thing comes to
U_X*0 + U_Y*((C_Y - (B - C_X)) / F_Y)
U_X*((C_X - (B - C_Y)) / F_X) + U_Y*0

U_X*((C_X - (B - C_Y)) / F_X) - U_Y*((C_Y - (B - C_X)) / F_Y)
(F_Y*U_X - F_X*U_Y)*(-B + C_X + C_Y)/(F_X*F_Y)

we've already assumed (-B + C_X + C_Y) is positive, since otherwise we could fully fund both X and Y

so the thing that matters is U_X/F_X - U_Y/F_Y
which is the same as before



if there's an asymmetry where X is cheap enough to fully fund but Y isn't,
the options are
t_X = 0
t_Y = (C_Y - (B - C_X)) / F_Y
and
t_X = C_X / F_X
t_Y = (C_Y - B) / F_Y

(U_X*(C_X / F_X) + U_Y*((C_Y - B) / F_Y)) - (U_X*0 + U_Y*((C_Y - (B - C_X)) / F_Y))

-C_X*U_Y/F_Y + C_X*U_X/F_X
which is the same result as for where we can't fully fund either project
and C_X is the chunk of our budget that we spend on X instead of Y


does it change things if instead of a fixed budget we have a constant annual income I?
assuming no outside funding:

fund X first and then Y
t_X = C_X/I
t_Y = C_X/I + C_Y/I
or fund Y first and then X
t_X = C_Y/I + C_X/I
t_Y = C_Y/I


(U_X*(C_Y/I + C_X/I) + U_Y*(C_Y/I)) - (U_X*(C_X/I) + U_Y*(C_X/I + C_Y/I))

(-C_X*U_Y + C_Y*U_X)/I
(C_X*C_Y) * (U_X/C_X - U_Y/C_Y) / I
and the sign is determined by
U_X/C_X - U_Y/C_Y
so we should fund whichever has higher ROI


and if U_Y = 0, the utility becomes (C_Y*U_X) / I, where C_Y/I is the amount of time we would've wasted funding Y and not X
so i think it makes some sense to think of funding X as being worth U_X / I utils per dollar,
but this does not imply that we should fund whichever has higher U,
since a higher cost project delays the alternative project by more than a lower cost project would.
weird.


if we do X, Y, and Z, in that order, the disutility is
(U_X*(C_X/I) + U_Y*(C_X/I + C_Y/I) + U_Z*(C_X/I + C_Y/I + C_Z/I))
(C_X*U_X + U_Y*(C_X + C_Y) + U_Z*(C_X + C_Y + C_Z))/I
and simulate taking away or adding a dollar by differentiating with respect to C_X,
this is still consistent with utils per dollar being U/I
and i guess it makes sense that the form is the same as where there's outside funding and utils per dollar is U/F
but the prioritization is different because now the cost of a project determines how much it delays other projects
which was not the case no income and only outside funding
utils per dollar seems like its only a meaningful thing if the number of dollars we have is finite.
well no, here we're assuming our money has no value once the projects are all done,
and since without outside funding eventually we finish everything after (C_X + C_Y) / I years,
we basically have a budget of C_X + C_Y.
no thats not right either, since we dont have that at time zero.
our limitation isnt an amount of money; our limitation here is that it takes time to fund stuff.
unlike the cases further up where we have B already and can just knock stuff out.
i feel like it makes more sense to just look at the utility from swapping the order of two things
than to try to frame it as "utility-per-something"


and then when theres nothing making the problems go away on their own, they actually kind of are infinite
so we can prioritize using U/C but we cant actually put a utils per dollar figure on there
or can we?
we should at least, given an annual income, be able to prioritize between problems that do and dont have outside funding

for the no outside funding case, it always takes the same amount of time to fund everything,
so there's no issues with the value of our income after all projects are completed.
if we've got an annual income and projects have outside funding,
our prioritization can affect the point in time where we're done with everything,
our U_X*(t_X) + U_Y*(t_Y) equation should also have a term for used up income K*I*Max(t_X, t_Y),
where K is utility per dollar after we're done with both projects
not sure if this is actually going to end up mattering.

so we minimize
U_X*(t_X) + U_Y*(t_Y) + K*I*Max(t_X, t_Y)

and compare two orderings by doing
(U_X*(t_X) + U_Y*(t_Y) + K*I*Max(t_X, t_Y)) - (U_X*(t_X) + U_Y*(t_Y) + K*I*Max(t_X, t_Y))

then the options are
fund X first and then Y
t_X = C_X / (F_X + I)
t_Y = Min(C_Y / F_Y, t_X + (C_Y - t_X*F_Y) / (F_Y + I))
    = Min(C_Y / F_Y, (C_Y + I*t_X)/(F_Y + I))
    = Min(C_Y / F_Y, (I*C_X + C_Y*(F_X + I))/((F_X + I)*(F_Y + I)))
or fund Y first and then X
t_X = Min(C_X / F_X, (I*C_Y + C_X*(F_Y + I))/((F_Y + I)*(F_X + I)))
t_Y = C_Y / (F_Y + I)


fund X first and X finishes first
(U_X*(C_X / (F_X + I)) + U_Y*((I*C_X + C_Y*(F_X + I))/((F_X + I)*(F_Y + I))) + K*I*((I*C_X + C_Y*(F_X + I))/((F_X + I)*(F_Y + I))))
(C_X*U_X*(F_Y + I) + (C_X*I + C_Y*(F_X + I))*(I*K + U_Y))/((F_X + I)*(F_Y + I))

fund X first and Y finishes first
(U_X*(C_X / (F_X + I)) + U_Y*(C_Y / F_Y) + K*I*(C_X / (F_X + I)))
(C_X*F_Y*(I*K + U_X) + C_Y*U_Y*(F_X + I))/(F_Y*(F_X + I))

fund Y first and X finishes first
(U_X*(C_X / F_X) + U_Y*(C_Y / (F_Y + I)) + K*I*(C_Y / (F_Y + I)))
(C_X*U_X*(F_Y + I) + C_Y*F_X*(I*K + U_Y))/(F_X*(F_Y + I))

fund Y first and Y finishes first
(U_X*((I*C_Y + C_X*(F_Y + I))/((F_Y + I)*(F_X + I))) + U_Y*(C_Y / (F_Y + I)) + K*I*((I*C_Y + C_X*(F_Y + I))/((F_Y + I)*(F_X + I))))
(C_Y*U_Y*(F_X + I) + (C_X*(F_Y + I) + C_Y*I)*(I*K + U_X))/((F_X + I)*(F_Y + I))


advantage of funding X where whichever project we fund finishes first
((C_Y*U_Y*(F_X + I) + (C_X*(F_Y + I) + C_Y*I)*(I*K + U_X))/((F_X + I)*(F_Y + I))) - ((C_X*U_X*(F_Y + I) + (C_X*I + C_Y*(F_X + I))*(I*K + U_Y))/((F_X + I)*(F_Y + I)))

I*(C_X*F_Y*K - C_X*U_Y - C_Y*F_X*K + C_Y*U_X)/(F_X*F_Y + F_X*I + F_Y*I + I**2)
the thing that affects the sign is
(C_X*F_Y*K - C_X*U_Y - C_Y*F_X*K + C_Y*U_X)
(F_Y*K/C_Y - U_Y/C_Y - F_X*K/C_X + U_X/C_X)*(C_X*C_Y)

(F_Y*K - U_Y)/C_Y - (F_X*K - U_X)/C_X

(U_X - F_X*K)/C_X - (U_Y - F_Y*K)/C_Y

which is a pretty clean looking expression and independent of I
so if it's up to us which thing gets done first,
we have a result that's pretty similar to the case with no outside funding (exactly the same if K=0)
and it says we shouldnt fund a project if the utility per year of having it done is less than K*F,
since in that case we'd be better off letting other people fund it and instead do whatever it is we do that produces K utils per dollar


if
C_X / F_X < C_Y / (F_Y + I)
I < (C_Y/C_X)*F_X - F_Y
X always finishes first
we can do this without loss of generality by just labelling the project with smaller C/F as X

the extra utility of funding X first where X finishes first either way is
((C_X*U_X*(F_Y + I) + C_Y*F_X*(I*K + U_Y))/(F_X*(F_Y + I))) - ((C_X*U_X*(F_Y + I) + (C_X*I + C_Y*(F_X + I))*(I*K + U_Y))/((F_X + I)*(F_Y + I)))

-C_X*I*(F_X*I*K + F_X*U_Y - F_Y*U_X - I*U_X)/(F_X*(F_X*F_Y + F_X*I + F_Y*I + I**2))
the thing that affects the sign is
-(F_X*I*K + F_X*U_Y - F_Y*U_X - I*U_X)
can we re-arrange this into a term that doesnt have Y stuff and a term that doesnt have X stuff?
-(F_X*(I*K + U_Y) - U_X*(F_Y + I))
(U_X*(F_Y + I) - F_X*(I*K + U_Y))
(U_X/F_X - (I*K + U_Y)/(F_Y + I))*(F_X*(F_Y + I))
and the sign only depends on
U_X/F_X - (I*K + U_Y)/(F_Y + I)

which is independent of C and looks like the results for when we had a fixed budget and no income
since we know Y is going to finish last, finishing Y means we start collecting K*I sooner,
so the utils per year after finishing Y is (I*K + U_Y).
and since if we fund Y first that means we only fund Y and never switch to X,
it makes sense that F_Y and I are added together into one thing.

it also looks like the K term matters but including it wasnt necessary to get sane answers, which i thought might happen

if we can choose which project is finished, outside funding only matters in so far as we're picking up K*F/C utils from other people's money

and if one project has outside funding and the other doesn't, the one without outside funding is Y the way we've labelled things,
since there's no way that it can be guaranteed to finish first,
and setting F_Y to zero gives a sane result
and then if the utility of one of the projects is zero we would never choose to fund it and its just a choice between funding the positive utility project or collecting K*I and the equations look like they pass that sanity check too

if we go back to
-C_X*I*(F_X*I*K + F_X*U_Y - F_Y*U_X - I*U_X)/(F_X*(F_X*F_Y + F_X*I + F_Y*I + I**2))
and re-do what we did to the numerator
C_X*I*((U_X/F_X - (I*K + U_Y)/(F_Y + I))*(F_X*(F_Y + I)))/(F_X*(F_X*F_Y + F_X*I + F_Y*I + I**2))
C_X*I*(U_X/F_X - (I*K + U_Y)/(F_Y + I))/(F_X + I)
((C_X/(F_X + I)) * I) * (U_X/F_X - (I*K + U_Y)/(F_Y + I))

C_X/(F_X + I) is the time it takes to finish X,
so ((C_X/(F_X + I)) * I) is money we spend to fund X before switching to funding Y
so i think it makes sense to think of U_X/F_X as a utility per dollar for X that can be compared to other causes
and if project Y doesnt exist and U_Y and F_Y are zero, (I*K + U_Y)/(F_Y + I) reduces to K,
which is exactly what represents our utility per dollar on stuff thats not X or Y

so it looks like U/F ends up being a legit utility per dollar measure in the income case only when we can't change the order of the projects.
but in the case with a budget and no income, U/F works if our budget is too small to fund either project, even if it's big enough to change the order in which they get done.
does this make sense?

i guess to judge whether something is a legit utility per dollar measure,
instead of having another project, we should just have a consumption option with the K utils per dollar
the case with a fixed budget where we don't have enough to fully fund the project
if we fund X
t_X = (C_X - B) / F_X
and if we don't fund X
t_X = C_X / F_X

the utility if we fund X is
-U_X*((C_X - B) / F_X)
the utility when we consume is
-U_X*(C_X / F_X) + K*B

and the utility from funding X is
-U_X*((C_X - B) / F_X) - (-U_X*(C_X / F_X) + K*B)
which is
B*(U_X/F_X - K)

so here clearly U_X/F_X represents utility per dollar on X

if we do have enough budget to fully fund X, we get
t_X = 0
or
t_X = C_X / F_X

the utility if we fund X is
0 + K*(B - C_X)
the utility when we consume is
-U_X*(C_X / F_X) + K*B

and the utility from funding X is
K*(B - C_X) - (-U_X*(C_X / F_X) + K*B)
C_X*(-F_X*K + U_X)/F_X
C_X*(U_X/F_X - K)

so again U_X/F_X is is legit utility per dollar


in the case where there's no outside funding, we have an annual income, and we have a consumption option,
we should never choose to consume because before the project is done,
because if we consume forever and never finish the project, we're leaving infinite utility on the table, assuming U > 0

if there is outside funding,
we can fund X and have
t_X = C_X / (F_X + I)
or only consume and have
t_X = C_X / F_X


we avoid the infinite consumption utility problem by just looking at utility up until C_X / F_X,
at which time the project will be done and we will be getting U_X + K*I utils per year in either case

so if we fund X,
we get U_X + K*I utils per year starting at
C_X / (F_X + I)
and zero before that.
and if we don't fund X,
we get K*I utils per year starting at time zero
and U_X + K*I utils per year starting at C_X / F_X

if we fund X, utility up until C_X / F_X is
((C_X / F_X) - (C_X / (F_X + I))) * (U_X + K*I)
and if we dont fund X, it's
(C_X / F_X) * (K*I)

the difference is
(((C_X / F_X) - (C_X / (F_X + I))) * (U_X + K*I)) - ((C_X / F_X) * (K*I))
-C_X*I*(F_X*K - U_X)/(F_X*(F_X + I))

C_X*I*(U_X/F_X - K)/(F_X + I)

(C_X*I)/(F_X + I) * (U_X/F_X - K)

where again U_X/F_X ends up being directly compared with K
and (C_X*I)/(F_X + I) is the amount of money we put into X
if I goes to infinity, this approaches the case where we have a fixed budget and we spend C_X all at once at time zero


Ok so i think U/F really does give us a direct comparison of project-like interventions (utility over time forever once it's fully funded) to consumption-like interventions (utility per dollar). And it matches the logic that we should always go for the project over consumption if F = 0 and U > 0. And it gives us a direct comparison of project-like interventions if we can spend money to complete a project in zero time. And it gives us a direct comparison of project-like interventions in the case where making/spending money takes time, but that time doesn't matter because we can't change the order in which things get done.
The case where it does not work is when we're comparing two project-like interventions and the one that we fund first is the one that gets done first. In that case, we should fund whichever has higher (U - K*F)/C.
I think what makes the result for the case where we have an income and can determine which intervention gets done first so qualitatively different from the case where have a stack of cash and can choose between two projects to knock out is that we have to take into account how much choosing to fund the first project delays our ability to fund the second project. (Everything here is assuming no diminishing returns to rate of funding, so it's always best to concentrate funding on one project to knock it out as soon as possible and never makes sense to split funding between projects and get neither one done.) And that delay is proportional to C.