Domenico Salvagnin

MIPLIB 2010 - Mixed Integer Programming Library version 5

This paper reports on the fifth version of the Mixed Integer Programming Library. The miplib 2010 is the first miplib release that has been assembled by a large group from academia and from industry, all of whom work in integer programming. There was mutual consent that the concept of the library had to be expanded in order to fulfill the needs of the community. The new version comprises 361 instances sorted into several groups. This includes the main benchmark test set of 87 instances, which are all solvable by today’s codes, and also the challenge test set with 164 instances, many of which are currently unsolved. For the first time, we include scripts to run automated tests in a predefined way. Further, there is a solution checker to test the accuracy of provided solutions using exact arithmetic.

Fast Approaches to Improve the Robustness of a Railway Timetable

The train timetabling problem (TTP) consists of finding a train schedule on a railway network that satisfies some operational constraints and maximizes some profit function that accounts for the efficiency of the infrastructure usage. In practical cases, however, the maximization of the objective function is not enough, and one calls for a robust solution that is capable of absorbing, as much as possible, delays/disturbances on the network. In this paper we propose and computationally analyze four different methods to improve the robustness of a given TTP solution for the aperiodic (noncyclic) case. The approaches combine linear programming (LP) and ad hoc stochastic programming/robust optimization techniques. We computationally compare the effectiveness and practical applicability of the four techniques under investigation on real-world test cases from the Italian railway company Trenitalia. The outcome is that two of the proposed techniques are very fast and provide robust solutions of comparable quality with respect to the standard (but very time consuming) stochastic programming approach.

Feasibility Pump 2.0

Finding a feasible solution of a given mixed-integer programming (MIP) model is a very important

Winner determination in voting trees with incomplete preferences and weighted votes

{\mathcal{NP}}

Thinning out Steiner trees: a node-based model for uniform edge costs

-complete problem that can be extremely hard in practice. Feasibility Pump (FP) is a heuristic scheme for finding a feasible solution to general MIPs that can be viewed as a clever way to round a sequence of fractional solutions of the LP relaxation, until a feasible one is eventually found. In this paper we study the effect of replacing the original rounding function (which is fast and simple, but somehow blind) with more clever rounding heuristics. In particular, we investigate the use of a diving-like procedure based on rounding and constraint propagation—a basic tool in Constraint Programming. Extensive computational results on binary and general integer MIPs from the literature show that the new approach produces a substantial improvement of the FP success rate, without slowing-down the method and with a significantly better quality of the feasible solutions found.

Self-splitting of workload in parallel computation

A new cut selection criterion for Benders’ cuts is proposed and computationally analyzed. The results show that the new criterion is more robust—and often considerably faster—than the standard ones.

Just MIP it

In multiagent settings where agents have different preferences, preference aggregation can be an important issue. Voting is a general method to aggregate preferences. We consider the use of voting tree rules to aggregate agents’ preferences. In a voting tree, decisions are taken by performing a sequence of pairwise comparisons in a binary tree where each comparison is a majority vote among the agents. Incompleteness in the agents’ preferences is common in many real-life settings due to privacy issues or an ongoing elicitation process. We study how to determine the winners when preferences may be incomplete, not only for voting tree rules (where the tree is assumed to be fixed), but also for the Schwartz rule (in which the winners are the candidates winning for at least one voting tree). In addition, we study how to determine the winners when only balanced trees are allowed. In each setting, we address the complexity of computing necessary (respectively, possible) winners, which are those candidates winning for all completions (respectively, at least one completion) of the incomplete profile. We show that many such winner determination problems are computationally intractable when the votes are weighted. However, in some cases, the exact complexity remains unknown. Since it is generally computationally difficult to find the exact set of winners for voting trees and the Schwartz rule, we propose several heuristics that find in polynomial time a superset of the possible winners and a subset of the necessary winners which are based on the completions of the (incomplete) majority graph built from the incomplete profiles.

A relax-and-cut framework for Gomory mixed-integer cuts

We address the exact solution of the famous esc instances of the quadratic assignment problem. These are extremely hard instances that remained unsolved---even allowing for a tremendous computing power---by using all previous techniques from the literature. During this challenging task we found that three ideas were particularly useful and qualified as a breakthrough for our approach. The present paper is about describing these ideas and their impact in solving esc instances. Our method was able to solve, in a matter of seconds or minutes on a single PC, all easy cases (all esc16* plus esc32e and esc32g ). The three very hard instances esc32c, esc32d , and esc64a were solved in less than half an hour, in total, on a single PC. We also report the solution, in about five hours, of tai64c . By using a facility-flow splitting procedure, we were also able to solve to proven optimality, for the first time, esc32h (in about two hours) as well as “the big fish” esc128 . (To our great surprise, the solution of the latter required just a few seconds on a single PC.)