Logistics Rules To Optimization

Logistics Rules To Optimization

Use this skill when the problem statement gives operational rules in words and the agent must turn them into an optimization model.

The goal is not only routing. The same translation pattern applies to transportation, dispatch, rebalancing, warehouse moves, staffing, scheduling, assignment, capacity planning, production, and service-level problems.

Rule Translation Workflow

1. List the entities.

   • Examples: vehicles, locations, depots, jobs, workers, machines, products, arcs, time periods.

2. Choose the decision state.

   • Binary variables for yes/no choices.
   • Integer variables for counts, loads, inventory, units moved.
   • Continuous variables for time, flow, cost, utilization, or fractional quantities.

3. Convert each business rule into one of these patterns.

   • Conservation: what enters equals what leaves, plus/minus changes.
   • Capacity: quantity cannot exceed a limit.
   • Linking: a quantity is allowed only if a binary decision is active.
   • Assignment: exactly one, at most one, or at least one choice.
   • Sequence: if one action follows another, update load/time/state.
   • Compatibility: prohibit impossible combinations.
   • Soft penalty: add slack for unmet demand or violation cost.

4. Add the objective last.

   • Keep named components such as travel cost, labor cost, inventory penalty, unmet demand penalty.

5. Extract and independently validate the answer.

   • Recompute routes, loads, assignments, inventory, penalties, and objective from the output data.

Variable Patterns

Selection and Assignment

Use binary variables when an option is selected.

pythonCopy code
x = {(i, j): model.addVar(vtype="B", name=f"x_{i}_{j}") for i in I for j in J}

Common rules:

pythonCopy code
# each item i assigned to exactly one option j
for i in I:
    model.addCons(quicksum(x[i, j] for j in J) == 1)

# option j can handle at most capacity[j] items
for j in J:
    model.addCons(quicksum(x[i, j] for i in I) <= capacity[j])

Route Arcs

Use binary arc variables when the order of visits matters.

pythonCopy code
x = {
    (v, i, j): model.addVar(vtype="B", name=f"x_{v}_{i}_{j}")
    for v in vehicles
    for i, j in arcs
}

Use x[v, i, j] = 1 to mean vehicle/resource v goes directly from node i to node j.

Visit Indicator

Define visit from route arcs instead of creating a second binary unless the model needs it repeatedly.

pythonCopy code
visit = quicksum(x[v, i, j] for j in to_nodes if j != i)

If a standalone variable is useful:

pythonCopy code
visit = {(v, i): model.addVar(vtype="B", name=f"visit_{v}_{i}") for v in vehicles for i in locations}

for v in vehicles:
    for i in locations:
        model.addCons(visit[v, i] == quicksum(x[v, i, j] for j in to_nodes if j != i))

Quantity, Load, Inventory, and Time

pythonCopy code
load = {(v, i): model.addVar(vtype="I", lb=0, ub=vehicle_capacity, name=f"load_{v}_{i}") for v in vehicles for i in nodes}
service = {(v, i): model.addVar(vtype="I", lb=-vehicle_capacity, ub=vehicle_capacity, name=f"service_{v}_{i}") for v in vehicles for i in locations}
inventory = {(i, t): model.addVar(vtype="I", lb=0, ub=storage_capacity[i], name=f"inventory_{i}_{t}") for i in locations for t in periods}
arrival = {(v, i): model.addVar(vtype="C", lb=0, name=f"arrival_{v}_{i}") for v in vehicles for i in nodes}

Use integer variables for physical unit counts when the output must be integer-valued.

Common Logistics Rules

Constraint Examples

Capacity

pythonCopy code
for r in resources:
    model.addCons(quicksum(amount[i, r] for i in items) <= capacity[r])

Quantity Allowed Only When Active

Use the tightest possible M.

pythonCopy code
for i in items:
    model.addCons(quantity[i] <= upper_bound[i] * use[i])

Soft Demand Satisfaction

pythonCopy code
unmet = {i: model.addVar(vtype="I", lb=0, name=f"unmet_{i}") for i in customers}

for i in customers:
    model.addCons(served[i] + unmet[i] >= demand[i])

penalty_cost = quicksum(penalty[i] * unmet[i] for i in customers)

Absolute Target Deviation

Never use Python abs() on solver expressions.

pythonCopy code
dev = {i: model.addVar(vtype="C", lb=0, name=f"dev_{i}") for i in items}

for i in items:
    model.addCons(actual[i] - target[i] <= dev[i])
    model.addCons(target[i] - actual[i] <= dev[i])

Depot Start and End

If every vehicle must be used:

pythonCopy code
for v in vehicles:
    model.addCons(quicksum(x[v, START, j] for j in locations) == 1)
    model.addCons(quicksum(x[v, i, END] for i in locations) == 1)

If vehicles are optional:

pythonCopy code
use_vehicle = {v: model.addVar(vtype="B", name=f"use_vehicle_{v}") for v in vehicles}

for v in vehicles:
    model.addCons(quicksum(x[v, START, j] for j in locations) == use_vehicle[v])
    model.addCons(quicksum(x[v, i, END] for i in locations) == use_vehicle[v])

Route Continuity and At-Most-Once Visits

pythonCopy code
for v in vehicles:
    for i in locations:
        incoming = quicksum(x[v, j, i] for j in from_nodes if j != i)
        outgoing = quicksum(x[v, i, j] for j in to_nodes if j != i)

        model.addCons(incoming == outgoing)
        model.addCons(outgoing <= 1)

This means vehicle v visits location i no more than once. It does not prevent a different vehicle from also visiting i.

Global Single-Visit Rule

Use only when the real rule forbids split service across vehicles/resources.

pythonCopy code
for i in locations:
    model.addCons(
        quicksum(x[v, i, j] for v in vehicles for j in to_nodes if j != i) <= 1
    )

Do not add this rule when a large pickup/dropoff target may need multiple vehicles.

Load or State Transition Along Selected Arcs

If state[j] = state[i] + change[j] when arc (i, j) is used:

pythonCopy code
M = 2 * vehicle_capacity

for v in vehicles:
    for i, j in arcs:
        change_at_j = service[v, j] if isinstance(j, int) else 0
        model.addCons(load[v, j] - load[v, i] - change_at_j <= M * (1 - x[v, i, j]))
        model.addCons(load[v, j] - load[v, i] - change_at_j >= -M * (1 - x[v, i, j]))

This pattern works for load, arrival time, battery charge, inventory state, and other route-dependent state variables. Pick M from real variable bounds.

Time Windows

pythonCopy code
for v in vehicles:
    for i in locations:
        visit_i = quicksum(x[v, i, j] for j in to_nodes if j != i)
        model.addCons(arrival[v, i] >= earliest[i] - horizon * (1 - visit_i))
        model.addCons(arrival[v, i] <= latest[i] + horizon * (1 - visit_i))

    for i, j in arcs:
        if j in locations:
            model.addCons(
                arrival[v, j] >= arrival[v, i] + service_time.get(i, 0) + travel_time[i, j] - horizon * (1 - x[v, i, j])
            )

Inventory Pickup/Dropoff Pattern

For rebalancing or material movement, define one signed service variable. Recommended convention:

• service[v, i] > 0: pickup from location i, vehicle load increases, location inventory decreases.
• service[v, i] < 0: dropoff to location i, vehicle load decreases, location inventory increases.

pythonCopy code
service = {
    (v, i): model.addVar(vtype="I", lb=-vehicle_capacity, ub=vehicle_capacity, name=f"service_{v}_{i}")
    for v in vehicles
    for i in locations
}

for v in vehicles:
    for i in locations:
        visit_i = quicksum(x[v, i, j] for j in to_nodes if j != i)
        model.addCons(service[v, i] <= vehicle_capacity * visit_i)
        model.addCons(service[v, i] >= -vehicle_capacity * visit_i)

for i in locations:
    net_change = quicksum(service[v, i] for v in vehicles)
    free_space = storage_capacity[i] - initial_inventory[i]

    model.addCons(net_change <= initial_inventory[i])  # pickup cannot exceed stock
    model.addCons(net_change >= -free_space)           # dropoff cannot exceed space

If the target is a desired net pickup/dropoff:

pythonCopy code
unmet = {i: model.addVar(vtype="I", lb=0, name=f"unmet_{i}") for i in locations}

for i in locations:
    net_change = quicksum(service[v, i] for v in vehicles)
    model.addCons(net_change - target[i] <= unmet[i])
    model.addCons(target[i] - net_change <= unmet[i])

Extract pickup/dropoff output as:

pythonCopy code
picked_up = max(service_value, 0)
dropped_off = max(-service_value, 0)

Objective Assembly

Build named components:

pythonCopy code
travel_cost = quicksum(distance[i, j] * x[v, i, j] for v in vehicles for i, j in arcs)
fixed_cost = quicksum(vehicle_fixed_cost[v] * use_vehicle[v] for v in vehicles)
penalty_cost = quicksum(penalty[i] * unmet[i] for i in customers)

model.setObjective(travel_cost + fixed_cost + penalty_cost, "minimize")