Network-Based Integer Programming

• Network-based integer programming is a modeling approach that leverages network structures to decompose complex decision problems into tractable flow-based subproblems.
• It employs action-flow coupling and dynamic branch-and-cut techniques to enforce global ordering constraints without imposing an exponential number upfront.
• The inherent linear formulation facilitates cost optimization and supports diverse applications like automated planning, logistics, and scheduling.

A network-based integer program is an integer programming (IP) model whose constraints and/or objective exploit the structure of a network, most commonly in the form of graphs or flows over discrete state spaces. These programs are fundamental to domains such as automated planning, supply chain optimization, and network design, where the evolution or transformation of a collection of interconnected states must be described and enforced by discrete decision variables. The distinguishing feature is that network-based IPs encode system dynamics, plan feasibility, or optimization goals as flows or transitions in a network, often decomposing complex problems into subproblems (e.g., one per state variable) coupled via auxiliary constraints.

1. Decomposition and Network Flow Modeling

A central paradigm in network-based IPs is the decomposition of a global combinatorial problem into multiple network flow subproblems, each corresponding to a distinct state variable. In the context of automated planning, as described by Vossen et al. ("Loosely Coupled Formulations for Automated Planning: An Integer Programming Perspective" (1111.0059)), each state variable $c$ with domain $V_c$ is modeled by a directed network where:

• Nodes: all possible values $f \in V_c$ the variable can assume.
• Arcs: transitions allowed between these values, either persistence (no change) or a change induced by an action.

The complete planning problem is then encoded as the simultaneous computation of feasible "paths" (flows) through these networks (one per state variable) starting with the initial assignments and reaching goal values if specified.

Flow conservation is enforced using integer variables for each arc and node at each time step (plan period), such as: $$\sum_{e\in \delta^+(f)} y_{c,e,t+1} + y_{c,f,t+1} = \sum_{e\in \delta^-(f)} y_{c,e,t} + y_{c,f,t}$$ where $y_{c,e,t}$ is a binary or integer variable indicating the usage of arc $e$ at period $t$, and $\delta^+(f)$/$\delta^-(f)$ are outgoing/incoming arcs at node $f$.

Action variables $x_{a,t} \in \{0,1\}$ indicate whether action $a$ is executed at period $t$. Linking (action implication) constraints enforce consistency between flow transitions and allowed actions: $\sum_{a: e \in E_a^c} x_{a,t} = y_{c,e,t}$ Preservation of required values (prevail conditions) is enforced by inequalities such as $x_{a,t} \le y_{c,f,t}$.

2. Parallelism and Generalized Formulations

Strict one-change-per-period policies (the "1SC" formulation), akin to Graphplan-style concurrency, are generalized to relax constraints on state variable transitions. The Generalized-1SC (G1SC), Generalized-2SC (G2SC), and PathSC formulations allow multiple state changes per variable per period or implicit value persistence before/after a transition. These generalized models admit more parallel (fewer periods) plans but require careful treatment to prevent action sequencing conflicts.

For example, the G1SC "prevail interaction" constraint: $$x_{a,t} \leq y_{c,f,t} + \sum_{e\in \delta^+(f)} y_{c,e,t}$$ permits value $f$ to be present either through persistence or implicitly during a transition.

However, the relaxation may cause cyclic dependencies among actions, necessitating additional constraints to ensure the set of simultaneous actions can be totally ordered without mutual interference.

3. Coupling and Merging: Global Feasibility via Branch-and-Cut

Action effects often span multiple state variable networks; thus, finding independently feasible flows is insufficient to guarantee a valid global plan. Merging the component flows requires enforcement of global acyclicity and action ordering. The implied precedence among actions is represented as a directed graph, where cycles indicate infeasibility (mutual conflicts).

Rather than precomputing an exponential number of ordering constraints, a branch-and-cut algorithm dynamically identifies and adds violated ordering (acyclicity) constraints during the solution process:

• Solve the LP relaxation with current cuts.
• Examine the implied precedence graph for cycles.
• For each cycle, generate a constraint such as: $\sum_{i=1}^k x_{a_i,t} \le k - 1$ (where $a_1, ..., a_k$ are actions forming a cycle)
• Add these as "cuts" to the IP and re-solve.

This incremental constraint separation is essential for scalability, as it avoids the upfront imposition of exponentially many constraints and outperforms both naive full enumeration and overly restrictive concurrency models.

4. Linear Objective Extension for Cost-Optimality

The network-based integer program structure is inherently linear, which enables direct integration of cost optimization objectives. Assigning per-action costs $c_a$, planning for minimum cost is modeled by: $\min \sum_{t=1}^T \sum_{a \in A} c_a x_{a,t}$ This enables cost-optimal planning, resource minimization, or utility maximization without changing the underlying network flow structure or relaxation framework.

Moreover, the approach supports additional linear constraints for extended forms, e.g., partial satisfaction planning, numeric resource tracking, or multi-objective criteria.

5. Computational Tradeoffs and Scalability

The key computational tradeoff is between constraints on action concurrency (parallelism), the size of the formulation, and the complexity of generating feasible global orderings. Allowing more concurrency (G1SC, G2SC, PathSC) reduces plan periods but increases the number and complexity of required ordering constraints. The number of variables may also grow rapidly if permitting multiple state changes per variable per period, particularly with large domains or high action arity.

Implementations must balance between fine-grained concurrency and tractable merging. The branch-and-cut algorithm ensures only necessary ordering implications are enforced, but enumeration of all cycles remains intractable for very large systems if not handled dynamically.

6. Applications and Limitations

This network-based IP methodology is particularly effective for:

• Automated planning in domains with loosely coupled state variables (e.g., logistics, multi-agent scheduling).
• Cost-optimal and partial satisfaction planning problems.
• Domains naturally modeled as flow or transition networks (e.g., resource allocation, supply chain recovery, scheduling).

The approach is extendable to numeric constraints and more complex domains, provided the state variables and action effects are suitably decomposable.

However, increased concurrency can lead to a combinatorial explosion in required ordering constraints, and certain generalizations (k-state changes per period) may induce an exponential number of variables. Some formulations are less capable of handling operators that transition a state variable from undefined to defined states.

7. Summary Table: Main Constructs in Network-Based Integer Programs

Construct	Mathematical Role	Example Formulation
State variable network	Models all possible transitions per variable	Flow conservation: $\sum y_{\cdot, t+1} = \sum y_{\cdot, t}$
Action variable $x_{a,t}$	Decision: apply action $a$ at period $t$	$x_{a,t} \in \{0,1\}$
Action-flow coupling	Enforces consistency between actions and flows	$\sum_{a: e \in E_a^c} x_{a,t} = y_{c,e,t}$
Ordering constraints	Ensures action sequence consistency	$\sum_{i=1}^k x_{a_i,t} \leq k - 1$ (for each cycle)
Cost objective	Minimizes cumulative action costs	$\min \sum_{t,a} c_a x_{a,t}$

This architecture, integrating network flow modeling, action coupling, and dynamic constraint generation via branch-and-cut, constitutes the modern paradigm for scalable and extensible network-based integer programming in complex planning and scheduling domains.