This is an interesting question. I need to get some sleep so I'll keep this short (apologies if it's a bit telegraphic), but I hope the following is helpful:

This sounds very similar to max-flow (but not quite identical).

If you have

*n* conversion processes and

*T* time steps, picture a graph with

*n* *T* nodes. Each node represents doing a particular process at a particular time. Then, you link all the nodes from one time to all the nodes at the next time. I'm picturing a vertical column of nodes for each time, and those columns arranged in order from early times to late times from left to right.

What you're going to do is optimize over flows on the edges.

What are our constraints? Let's look at an individual node. Say you have a process with two inputs and two outputs. The conversion it does is,

INPUT: 2 units of input resource 1 and 3 units of input resource 2

OUTPUT: 4 units of output resource 1 and 7 units of output resource 2.

Say the amounts of input resources you put in are

*a* and

*b*, and the amounts of output resources are

*x* and

*y*. Then, introducing a new variable

*z* to represent the total number of "trades" done, the above is summarized by the constraints,

z <= a/2

z <= b/3

x <= 4 z

y <= 7 z

so you have inequality constraints relating the flows on your edges. Additionally, all the flows need to be nonnegative, meaning that they go the right direction in time:

x >= 0

y >= 0

a >= 0

b >= 0 .

You also have some equality constraints: The flows into the nodes at the far left of the graph (the "earliest" ones) are fixed; these are the quantities you start out with. And the flows at the far right of the graph have "greater-than" constraints, to say that you want produced

*at least** this much* of each resource.

Finally, you have a cost, which is just a weighted sum of the flows.

So what does this boil down to?

- You have as many variables as you have edges [EDIT: plus nodes; you also have the

*"z*" variables]

- You have a linear cost (a weighted sum)

- You have linear inequality constraints

You can solve this exactly as an integer linear program, or you can relax the answer to be real (instead of just integer), in which case you just have a standard LP.

Does this formulation leave anything out?

**Edited by Emergent, 30 October 2012 - 05:06 AM.**