33,815 research outputs found
Faster Algorithms for Integer Programs with Block Structure
We consider integer programming problems where has a (recursive)
block-structure generalizing "-fold integer programs" which recently
received considerable attention in the literature. An -fold IP is an integer
program where consists of repetitions of submatrices on the top horizontal part and repetitions of a
matrix on the diagonal below the top part.
Instead of allowing only two types of block matrices, one for the horizontal
line and one for the diagonal, we generalize the -fold setting to allow for
arbitrary matrices in every block. We show that such an integer program can be
solved in time
(ignoring logarithmic factors). Here is an upper bound on the
largest absolute value of an entry of and is the largest
binary encoding length of a coefficient of . This improves upon the
previously best algorithm of Hemmecke, Onn and Romanchuk that runs in time
. In particular, our
algorithm is not exponential in the number of columns of and .
Our algorithm is based on a new upper bound on the -norm of an element
of the "Graver basis" of an integer matrix and on a proximity bound between the
LP and IP optimal solutions tailored for IPs with block structure. These new
bounds rely on the "Steinitz Lemma".
Furthermore, we extend our techniques to the recently introduced "tree-fold
IPs", where we again present a more efficient algorithm in a generalized
setting
An Algorithmic Theory of Integer Programming
We study the general integer programming problem where the number of
variables is a variable part of the input. We consider two natural
parameters of the constraint matrix : its numeric measure and its
sparsity measure . We show that integer programming can be solved in time
, where is some computable function of the
parameters and , and is the binary encoding length of the input. In
particular, integer programming is fixed-parameter tractable parameterized by
and , and is solvable in polynomial time for every fixed and .
Our results also extend to nonlinear separable convex objective functions.
Moreover, for linear objectives, we derive a strongly-polynomial algorithm,
that is, with running time , independent of the rest of
the input data.
We obtain these results by developing an algorithmic framework based on the
idea of iterative augmentation: starting from an initial feasible solution, we
show how to quickly find augmenting steps which rapidly converge to an optimum.
A central notion in this framework is the Graver basis of the matrix , which
constitutes a set of fundamental augmenting steps. The iterative augmentation
idea is then enhanced via the use of other techniques such as new and improved
bounds on the Graver basis, rapid solution of integer programs with bounded
variables, proximity theorems and a new proximity-scaling algorithm, the notion
of a reduced objective function, and others.
As a consequence of our work, we advance the state of the art of solving
block-structured integer programs. In particular, we develop near-linear time
algorithms for -fold, tree-fold, and -stage stochastic integer programs.
We also discuss some of the many applications of these classes.Comment: Revision 2: - strengthened dual treedepth lower bound - simplified
proximity-scaling algorith
New Bounds on Augmenting Steps of Block-Structured Integer Programs
Iterative augmentation has recently emerged as an overarching method for solving Integer Programs (IP) in variable dimension, in stark contrast with the volume and flatness techniques of IP in fixed dimension. Here we consider 4-block n-fold integer programs, which are the most general class considered so far. A 4-block n-fold IP has a constraint matrix which consists of n copies of small matrices A, B, and D, and one copy of C, in a specific block structure. Iterative augmentation methods rely on the so-called Graver basis of the constraint matrix, which constitutes a set of fundamental augmenting steps. All existing algorithms rely on bounding the ??- or ?_?-norm of elements of the Graver basis. Hemmecke et al. [Math. Prog. 2014] showed that 4-block n-fold IP has Graver elements of ?_?-norm at most ?_FPT(n^{2^{s_D}}), leading to an algorithm with a similar runtime; here, s_D is the number of rows of matrix D and ?_FPT hides a multiplicative factor that is only dependent on the small matrices A,B,C,D, However, it remained open whether their bounds are tight, in particular, whether they could be improved to ?_FPT(1), perhaps at least in some restricted cases.
We prove that the ?_?-norm of the Graver elements of 4-block n-fold IP is upper bounded by ?_FPT(n^{s_D}), improving significantly over the previous bound ?_FPT(n^{2^{s_D}}). We also provide a matching lower bound of ?(n^{s_D}) which even holds for arbitrary non-zero lattice elements, ruling out augmenting algorithm relying on even more restricted notions of augmentation than the Graver basis. We then consider a special case of 4-block n-fold in which C is a zero matrix, called 3-block n-fold IP. We show that while the ?_?-norm of its Graver elements is ?(n^{s_D}), there exists a different decomposition into lattice elements whose ?_?-norm is bounded by ?_FPT(1), which allows us to provide improved upper bounds on the ?_?-norm of Graver elements for 3-block n-fold IP. The key difference between the respective decompositions is that a Graver basis guarantees a sign-compatible decomposition; this property is critical in applications because it guarantees each step of the decomposition to be feasible. Consequently, our improved upper bounds let us establish faster algorithms for 3-block n-fold IP and 4-block IP, and our lower bounds strongly hint at parameterized hardness of 4-block and even 3-block n-fold IP. Furthermore, we show that 3-block n-fold IP is without loss of generality in the sense that 4-block n-fold IP can be solved in FPT oracle time by taking an algorithm for 3-block n-fold IP as an oracle
biobambam: tools for read pair collation based algorithms on BAM files
Sequence alignment data is often ordered by coordinate (id of the reference
sequence plus position on the sequence where the fragment was mapped) when
stored in BAM files, as this simplifies the extraction of variants between the
mapped data and the reference or of variants within the mapped data. In this
order paired reads are usually separated in the file, which complicates some
other applications like duplicate marking or conversion to the FastQ format
which require to access the full information of the pairs. In this paper we
introduce biobambam, an API for efficient BAM file reading supporting the
efficient collation of alignments by read name without performing a complete
resorting of the input file and some tools based on this API performing tasks
like marking duplicate reads and conversion to the FastQ format. In comparison
with previous approaches to problems involving the collation of alignments by
read name like the BAM to FastQ or duplication marking utilities in the Picard
suite the approach of biobambam can often perform an equivalent task more
efficiently in terms of the required main memory and run-time.Comment: 17 pages, 3 figures, 2 table
Survey on Combinatorial Register Allocation and Instruction Scheduling
Register allocation (mapping variables to processor registers or memory) and
instruction scheduling (reordering instructions to increase instruction-level
parallelism) are essential tasks for generating efficient assembly code in a
compiler. In the last three decades, combinatorial optimization has emerged as
an alternative to traditional, heuristic algorithms for these two tasks.
Combinatorial optimization approaches can deliver optimal solutions according
to a model, can precisely capture trade-offs between conflicting decisions, and
are more flexible at the expense of increased compilation time.
This paper provides an exhaustive literature review and a classification of
combinatorial optimization approaches to register allocation and instruction
scheduling, with a focus on the techniques that are most applied in this
context: integer programming, constraint programming, partitioned Boolean
quadratic programming, and enumeration. Researchers in compilers and
combinatorial optimization can benefit from identifying developments, trends,
and challenges in the area; compiler practitioners may discern opportunities
and grasp the potential benefit of applying combinatorial optimization
- …