Generalized dynamic programming methods in integer programming

By relaxing the nonnegativity constraints on a set of basic variables, an integer programming problem can be reduced to a shortest route problem over a finite Abelian group. Here it is shown how given a similar relaxation on any set of variables, a structurally simpler problem is obtained, which can be regarded as a shortest route problem over an Abelian (but not necessarily finite) group. In particular if the non-negativity constraints are relaxed on all but one of a set of basic variables, a knapsack (or very close to knapsack) problem is obtained, which either gives the solution of the integer problem, or when solved by dynamic programming provides bounds at least as strong as those provided by the above group problem. The difficulty that arises when the order of groups encountered is very large is also considered in the same framework, and by further relaxation it is shown how the groups can be reduced to manageable size, which can be used to provide simple bounds for the above group problem. Finally applications of these results are suggested with reference to various existing integer programming algorithms.

Elementary Linear Programming with Applications

Ranking in quadratic integer programming problems

Optimal load clipping with time of use rates

The problem of designing fibre-optic networks for local-access telecommunications generates (at least) three non-trivial subproblems. In the first of these subproblems one must determine how many fibre-optic cables (fibres) are required at either end of a street. In the next subproblem a minimum-cost network must be designed to support the fibres. The network must also provide distinct paths from either end of the street to the central exchange(s). Finally, the fibre-optic cables must be placed in protective covers. These covers are available in a number of different sizes, allowing some flexibility when covering each section of the network. In this paper we describe a dynamic programming (DP) formulation for finding a minimum-cost (protective) covering for the network (the third of the subproblems). This problem is a generalised set covering problem with side constraints and is further complicated by the introduction of fixed and variable welding costs. The DP formulation selects covers along each arc (in the network), but cannot exactly model the fixed costs and so does not guarantee optimality. We also describe an integer programming (IP) formulation for assessing the quality of the DP solutions. The cost of the networks constructed by the IP model is less than those designed using the DP model, but the saving is not significant for the problems examined (less than 0.1%). This indicates that the DP model will generally give very good solutions. Furthermore, as the problem dimensions grow, DP gives significantly better solution times than IP.

General integer programming (IP) applications and solutions are briefly reviewed in this chapter. Section 4.1 outlines general formulation techniques for IP. Section 4.2 discusses state of the art solutions of general IP problems including classical enumerative and heuristic approaches (ie. simulated annealing). Recent successes in polyhedral approaches to solving partially structured IPs are outlined in section 4.3. Finally the definition and partial structure of the node packing problem (the focus of architectural synthesis) is given in section 4.4. (The notation for a graph is G=(V,E), where V is the set of vertices and E is the set of edges).KeywordsBipartite GraphInteger ProgrammingTravel Salesman ProblemKnapsack ProblemInteger VariableThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Many fundamental NP-hard problems can be formulated as integer linear programs (ILPs). A famous algorithm by Lenstra solves ILPs in time that is exponential only in the dimension of the program, and polynomial in the size of the ILP. That algorithm became a ubiquitous tool in the design of fixed-parameter algorithms for NP-hard problems, where one wishes to isolate the hardness of a problemby some parameter. However, in many cases using Lenstra's algorithm has two drawbacks: First, the run time of the resulting algorithms is often doubly-exponential in the parameter, and second, an ILP formulation in small dimension cannot easily express problems involving many different costs. Inspired by the work of Hemmecke, Onn and Romanchuk [Math. Prog. 2013], we develop a single-exponential algorithm for so-called combinatorial n-fold integer programs, which are remarkably similar to prior ILP formulations for various problems, but unlike them, also allow variable dimension. We then apply our algorithm to a few representative problems like Closest String, Swap Bribery, Weighted Set Multicover, and obtain exponential speedups in the dependence on the respective parameters, the input size, or both. Unlike Lenstra's algorithm, which is essentially a bounded search tree algorithm, our result uses the technique of augmenting steps. At its heart is a deep result stating that in combinatorial n-fold IPs, existence of an augmenting step implies existence of a \local" augmenting step, which can be found using dynamic programming. Our results provide an important insight into many problems by showing that they exhibit this phenomenon, and highlights the importance of augmentation techniques.

Contributors

Elementary (flux) modes (EMs) have served as a valuable tool for investigating structural and functional properties of metabolic networks. Identification of the full set of EMs in genome-scale networks remains challenging due to combinatorial explosion of EMs in complex networks. It is often, however, that only a small subset of relevant EMs needs to be known, for which optimization-based sequential computation is a useful alternative. Most of the currently available methods along this line are based on the iterative use of mixed integer linear programming (MILP), the effectiveness of which significantly deteriorates as the number of iterations builds up. To alleviate the computational burden associated with the MILP implementation, we here present a novel optimization algorithm termed alternate integer linear programming (AILP). Our algorithm was designed to iteratively solve a pair of integer programming (IP) and linear programming (LP) to compute EMs in a sequential manner. In each step, the IP identifies a minimal subset of reactions, the deletion of which disables all previously identified EMs. Thus, a subsequent LP solution subject to this reaction deletion constraint becomes a distinct EM. In cases where no feasible LP solution is available, IP-derived reaction deletion sets represent minimal cut sets (MCSs). Despite the additional computation of MCSs, AILP achieved significant time reduction in computing EMs by orders of magnitude. The proposed AILP algorithm not only offers a computational advantage in the EM analysis of genome-scale networks, but also improves the understanding of the linkage between EMs and MCSs. The software is implemented in Matlab, and is provided as supplementary information . hyunseob.song@pnnl.gov. Supplementary data are available at Bioinformatics online.

Given an initial marking and final marking for a Petri net model, an optimal firing sequence problem is defined as the problem to find an optimal transition firing sequence to minimize the objective function. For the purpose of analysis of general integer programming problems, we propose a Petri net representation and reachability analysis of integer programming problems. In the proposed method, an integer programming problem is converted into the optimal firing sequence problem of Petri nets. By utilizing the proposed algorithm, integer programming problems can be visualized and analyzed by the Petri net theory. We apply the proposed methodology to the scheduling problems of dual armed cluster tools. The valid inequalities are derived from the reachability analysis. Numerical results show that those valid inequalities can significantly reduce the computational time of the original integer programming problem.

The work presented in this paper focuses on behavioral level power optimization. Specifically, we address the problem of scheduling a data-flow graph under latency constraints. We have developed an integer linear program (ILP) model and a Modified Force-Directed Scheduling (MFDS) that minimize the peak power while satisfying timing constraints. Our integer linear programming method extends the traditional ILP approach that minimizes resources to include peak power consideration while adding extensions for multi-cycle and pipelined arithmetic components. In our benchmark results, the peak power is reduced after scheduling based on ILP method and MFDS algorithm and is reduced significantly after scheduling and pipelining are both applied. The results obtained by the heuristic-based algorithms (MFDS) match very well with those obtained by the integer linear programming (ILP) methods. While the results obtained by heuristic-based algorithm are approximate, the results obtained by the integer linear programming methods are optimal. But the heuristic-based algorithm is faster than the integer linear programming methods.

In the context of eXtended Generalized Fat Tree (XGFT) topologies, widely used in HPC and datacenter network designs, we propose a generic method, based on Integer Linear Programming (ILP), to efficiently determine optimal routes for arbitrary workloads. We propose a novel approach that combines ILP with dynamic programming, effectively reducing the time to solution. Specifically, we divide the network into smaller subdomains optimized using a custom ILP formulation that ensures global optimality of local solutions. Local solutions are then combined into an optimal global solution using dynamic programming. Finally, we demonstrate through a series of extensive benchmarks that our approach scales in practice to networks interconnecting several thousands of nodes, using a single-threaded, freely available linear programming solver on commodity hardware, with the potential for higher scalability by means of commercial, parallel solvers.

SummaryNetwork function virtualization (NFV) is a name of technology for replacing hardware‐based network functions with software programs. Virtual network function (VNF) is a software program that replaces the hardware‐based network functionality. The replacement of the hardware‐based network functions (middleboxes) with software programs promises the on‐demand provisioning of network functions and reduces capital and operational expenses of the network. Due to this replaced network can adapt to the different network functions. Network service providers deploy various network services with different objectives, such as reducing the network's active servers and traffic latency or network operational expenses. In this article, a VNF placement problem is studied to optimize the total operating costs of the networks. To solve the VNF placement problem, we proposed an integer linear program (ILP) model, which has been implemented using CPLEX. Although an ILP‐based approach gives an optimal solution, it takes a long execution time to find the solution. Due to the long execution time, the ILP‐based approach is not suitable for the real‐time VNF placement problem. To address this challenge, we proposed a heuristic based on dynamic programming that performs better than the existing approaches. The simulation results of the proposed solution using real‐world topologies show that the heuristic approach finds a feasible solution that is only 1 to 1.34 times far from the optimal one. Moreover, experimental results show that the proposed heuristic is 15 to 423 times faster than the ILP.

Maastricht University is offering a MBA program for people that have a bachelor degree and at least 5 years of working experience. Within the MBA program, students work in groups of 5 during a two year cycle. This thesis is about the formation of the student groups. The MBA program contains 60 students. Every year, two intake moments take place that usually allow 15 new students to enter. All 60 students follow the same course at the same time, implying that the order in which a student follows the courses depends only on the moment at which he/she starts the program. Every two periods, The university creates new student groups according to a set of hard and soft constraints, such that well-diversified groups are formed. Therefore, the student-with-student history, gender, nationality, and level of expertise of each student is taken into account. Hence a mapping from a set of students to groups is created that takes into account the corresponding constraints. The university chooses a group leader for each group. Two general solution methods are applied to the MBA sectioning problem. The first method uses the simplex algorithm to solve the problem. Therefore an integer linear program formulation of the problem was needed, and used as an input for an efficient ILP solver. The second approach starts with an initial feasible solution and improves upon this feasible solution using different improvement algorithms. The quality of each feasible solution depends on the calculated objective function value that measures the level of satisfaction of the different constraints. Different initial solution and improvement algorithms are discussed that help to obtain a feasible solution with an objective function value that is as low as possible. The implemented improvement algorithms are the Descent Improvement algorithm, Tabu Search, Simulated Annealing, and the Bipartite Weighted Matching Improvement algorithm. The first three algorithms make individual students swap between existing group formations. The Bipartite Weighted Matching Improvement algorithm iteratively selects a student from each group, and finds local optimal solutions for a bipartite matching problem in order to improve the overall objective value of the whole problem. In order to test the algorithms, one has to make sure that the instance on which the algorithms are tested mimics a real life example. Therefore, a simulation program is established that mimics the two year cycle and produces such an instance. Empirical results show that the best improvement algorithm considered is the Bipartite Weighted Matching Improvement algorithm. This algorithm, combined with an initial solution algorithm, is now being implemented into the current computer system of Maastricht University.

Contributors