# Multi-Commodity Flow Problem¶

This example illustrates a model for the Multi-Commodity Flow Problem (MCF).

In the following, notation \(c_*\) refers to the cost of entity \(*\), and similarly \(x_*\) refers to the variable, e.g., \(c_e\) is the cost of edge \(e\). Entity should be clear from context.

In the minimum cost MCF he objective is to minimize the total cost of transporting commodities through a network from origin to destination vertices. The edges of the network are capacitated.

Let \(g(V,E)\) be a graph and let \(K\) be the set of commodities each with an origin \(o_k\) and destination \(d_k\) and a demand \(b_k\). Edge capacities is denoted by \(u_e\) for \(e \in E\).

The problem can be formulated as a path based model

$\begin{aligned} \min{ } & \sum_{k \in K} \sum_{p \in P^k} c_p \lambda_p \\ \text{s.t. } & \sum_{p \in P^k} \lambda_p \geq b_k & & k \in K \\ & \sum_{k \in K} \sum_{p \in P^k} \alpha_p^e \lambda_p \geq u_e & & e \in E \\ & \lambda_p \geq 0 && k \in K, p \in P^k \end{aligned}$

where each path \(p \in P^k\) for commodity \(k \in K\) is feasible in \(g(V,E)\) with accumulated edge cost \(c_p = \sum_{e \in p} c_e\) and \(\alpha_p^e = \sum_{e \in p} 1\) expresses \(p\)'s usage of edge \(e\).

The \(\lambda\)'s are not directly available for modelling.

The problem can in Flowty be modeled as

$\begin{aligned} \min & \sum_{e \in E} c_e x_e + \sum_{k \in K} c_ky_k \\ \text{s.t. } & x_k + y_k \geq b_k & & k \in K \\ & x_e \leq u_e & & e \in E \\ & 0 \leq x_k \leq b_k && k \in K \\ \end{aligned}$

with the graph described as above, and domain of each path continuous. The model exploits that the \(|K|\) subproblems for each commodity share a common graph and therefore allows us to model on a single edge in the edge capacity constraint. See the concepts section and modelling tour for more details.

Fetching data

To fetch the benchmark data check out the examples.

```
# Multi Commodity Flow
import flowty
import fetch_mcf
name, n, m, k, E, C, U, O, D, B = fetch_mcf.fetch("planar800")
model = flowty.Model()
# define graph
graph = model.addGraph(costs=C, edges=E)
# create subproblems
subproblems = [
model.addSubproblem(graph, source=o, target=d, obj=0, lb=0, ub=b, domain="C")
for o, d, b in zip(O, D, B)
]
penalty = sum(C) + 1
# create penalty variables
Y = [model.addVariable(obj=penalty, lb=0, ub=b, domain="C") for b in B]
# demand constraints
for y, s, b in zip(Y, subproblems, B):
model += y + s >= b
# capacity constraints
lazy = True
for e, u in zip(graph.edges, U):
model += e <= u, lazy
status = model.solve()
solution = model.getSolution()
if solution:
print(f"Cost {(solution.cost)}")
for path in solution.paths:
print(f"Commodity {path.subproblem.id}: {path.x}")
for edge in path.edges:
print(f"{edge}")
for var in solution.variables:
print(f"Penalty {var.variable.id}: {var.x}")
```