PART I: FOUNDATIONS 1. Introduction to Fixed-Parameter Algorithms 2. Preliminaries and Agreements 3. Parameterized Complexity Theory - A Primer 4. Vertex Cover - An Illustrative Example 5. The Art of Problem Parameterization 6. Summary and Concluding Remarks PART II: ALGORITHMIC METHODS 7. Data Reduction and Problem Kernels 8. Depth-Bounded Search Trees 9. Dynamic Programming 10. Tree Decompositions of Graphs 11. Further Advanced Techniques 12. Summary and Concluding Remarks PART III: SOME THEORY, SOME CASE STUDIES 13. Parameterized Complexity Theory 14. Connections to Approximation Algorithms 15. Selected Case Studies 16. Zukunftsmusik References Index

Invitation to fixed-parameter algorithms

Constraint programming is a powerful paradigm for solving combinatorial search problems that draws on a wide range of techniques from artificial intelligence, computer science, databases, programming languages, and operations research. Constraint programming is currently applied with success to many domains, such as scheduling, planning, vehicle routing, configuration, networks, and bioinformatics.

The aim of this handbook is to capture the full breadth and depth of the constraint programming field and to be encyclopedic in its scope and coverage. While there are several excellent books on constraint programming, such books necessarily focus on the main notions and techniques and cannot cover also extensions, applications, and languages. The handbook gives a reasonably complete coverage of all these lines of work, based on constraint programming, so that a reader can have a rather precise idea of the whole field and its potential. Of course each line of work is dealt with in a survey-like style, where some details may be neglected in favor of coverage. However, the extensive bibliography of each chapter will help the interested readers to find suitable sources for the missing details. Each chapter of the handbook is intended to be a self-contained survey of a topic, and is written by one or more authors who are leading researchers in the area.

The intended audience of the handbook is researchers, graduate students, higher-year undergraduates and practitioners who wish to learn about the state-of-the-art in constraint programming. No prior knowledge about the field is necessary to be able to read the chapters and gather useful knowledge. Researchers from other fields should find in this handbook an effective way to learn about constraint programming and to possibly use some of the constraint programming concepts and techniques in their work, thus providing a means for a fruitful cross-fertilization among different research areas.

The handbook is organized in two parts. The first part covers the basic foundations of constraint programming, including the history, the notion of constraint propagation, basic search methods, global constraints, tractability and computational complexity, and important issues in modeling a problem as a constraint problem. The second part covers constraint languages and solver, several useful extensions to the basic framework (such as interval constraints, structured domains, and distributed CSPs), and successful application areas for constraint programming.

- Covers the whole field of constraint programming
- Survey-style chapters
- Five chapters on applications

Table of Contents

Foreword (Ugo Montanari) 
Part I : Foundations
Chapter 1. Introduction (Francesca Rossi, Peter van Beek, Toby Walsh) 
Chapter 2. Constraint Satisfaction: An Emerging Paradigm (Eugene C. Freuder, Alan K. Mackworth) 
Chapter 3. Constraint Propagation (Christian Bessiere) 
Chapter 4. Backtracking Search Algorithms (Peter van Beek) 
Chapter 5. Local Search Methods (Holger H. Hoos, Edward Tsang) 
Chapter 6. Global Constraints (Willem-Jan van Hoeve, Irit Katriel)
Chapter 7. Tractable Structures for CSPs (Rina Dechter)
Chapter 8. The Complexity of Constraint Languages
(David Cohen, Peter Jeavons) 
Chapter 9. Soft Constraints (Pedro Meseguer, Francesca Rossi, Thomas Schiex) 
Chapter 10. Symmetry in Constraint Programming
(Ian P. Gent, Karen E. Petrie, Jean-Francois Puget)
Chapter 11. Modelling (Barbara M. Smith) 
Part II : Extensions, Languages, and Applications

Chapter 12. Constraint Logic Programming (Kim Marriott, Peter J. Stuckey, Mark Wallace) 
Chapter 13. Constraints in Procedural and Concurrent Languages (Thom Fruehwirth, Laurent Michel, Christian Schulte)
Chapter 14. Finite Domain Constraint Programming Systems (Christian Schulte, Mats Carlsson) 
Chapter 15. Operations Research Methods in Constraint Programming (John Hooker) 
Chapter 16. Continuous and Interval Constraints(Frederic Benhamou, Laurent Granvilliers) 
Chapter 17. Constraints over Structured Domains
(Carmen Gervet) 
Chapter 18. Randomness and Structure (Carla Gomes, Toby Walsh)
Chapter 19. Temporal CSPs (Manolis Koubarakis)
Chapter 20. Distributed Constraint Programming
(Boi Faltings) 
Chapter 21. Uncertainty and Change (Kenneth N. Brown, Ian Miguel)
Chapter 22. Constraint-Based Scheduling and Planning
(Philippe Baptiste, Philippe Laborie, Claude Le Pape, Wim Nuijten)
Chapter 23. Vehicle Routing (Philip Kilby, Paul Shaw) 
Chapter 24. Configuration (Ulrich Junker)
Chapter 25. Constraint Applications in Networks
(Helmut Simonis)
Chapter 26. Bioinformatics and Constraints (Rolf Backofen, David Gilbert)

/pdf/handbook-of-constraint-programming-53srutguo2.pdf

Handbook of Constraint Programming

https://grfia.dlsi.ua.es/ml/algorithms/references/editsurvey_bille.pdf

A survey on tree edit distance and related problems

There has been significant recent interest in parallel frameworks for processing graphs due to their applicability in studying social networks, the Web graph, networks in biology, and unstructured meshes in scientific simulation. Due to the desire to process large graphs, these systems have emphasized the ability to run on distributed memory machines. Today, however, a single multicore server can support more than a terabyte of memory, which can fit graphs with tens or even hundreds of billions of edges. Furthermore, for graph algorithms, shared-memory multicores are generally significantly more efficient on a per core, per dollar, and per joule basis than distributed memory systems, and shared-memory algorithms tend to be simpler than their distributed counterparts.In this paper, we present a lightweight graph processing framework that is specific for shared-memory parallel/multicore machines, which makes graph traversal algorithms easy to write. The framework has two very simple routines, one for mapping over edges and one for mapping over vertices. Our routines can be applied to any subset of the vertices, which makes the framework useful for many graph traversal algorithms that operate on subsets of the vertices. Based on recent ideas used in a very fast algorithm for breadth-first search (BFS), our routines automatically adapt to the density of vertex sets. We implement several algorithms in this framework, including BFS, graph radii estimation, graph connectivity, betweenness centrality, PageRank and single-source shortest paths. Our algorithms expressed using this framework are very simple and concise, and perform almost as well as highly optimized code. Furthermore, they get good speedups on a 40-core machine and are significantly more efficient than previously reported results using graph frameworks on machines with many more cores.

Ligra: a lightweight graph processing framework for shared memory

Knowledge Representation, which lies at the core of Artificial Intelligence, is concerned with encoding knowledge on computers to enable systems to reason automatically. The Handbook of Knowledge Representation is an up-to-date review of twenty-five key topics in knowledge representation, written by the leaders of each field.This book is an essential resource for students, researchers and practitioners in all areas of Artificial Intelligence. * Make your computer smarter* Handle qualitative and uncertain information* Improve computational tractability to solve your problems easily

Handbook of Knowledge Representation

Reconfiguration is concerned with relationships among solutions to a problem instance, where the reconfiguration of one solution to another is a sequence of steps such that each step produces an intermediate feasible solution. The solution space can be represented as a reconfiguration graph, where two vertices representing solutions are adjacent if one can be formed from the other in a single step. Work in the area encompasses both structural questions (Is the reconfiguration graph connected?) and algorithmic ones (How can one find the shortest sequence of steps between two solutions?) This survey discusses techniques, results, and future directions in the area.

https://www.mdpi.com/1999-4893/11/4/52/pdf

Introduction to Reconfiguration

We study the parameterized complexity of detecting backdoor sets for instances of the propositional satisfiability problem (SAT) with respect to the polynomially solvable classes horn and 2-cnf. A backdoor set is a subset of variables; for a strong backdoor set, the simplified formulas resulting from any setting of these variables is in a polynomially solvable class, and for a weak backdoor set, there exists one setting which puts the satisfiable simplified formula in the class. We show that with respect to both horn and 2-cnf classes, the detection of a strong backdoor set is fixed-parameter tractable (the existence of a set of size k for a formula of length N can be decided in time f(k)NO(1)), but that the detection of a weak backdoor set is W[2]-hard, implying that this problem is not fixed-parameter tractable.

/pdf/detecting-backdoor-sets-with-respect-to-horn-and-binary-44ztthcpb7.pdf

Detecting Backdoor Sets with Respect to Horn and Binary Clauses.

On Graph Powers for Leaf-Labeled Trees

We consider graph drawings in which vertices are assigned to layers and edges are drawn as straight line-segments between vertices on adjacent layers. We prove that graphs admitting crossing-free h-layer drawings (for fixed h) have bounded pathwidth. We then use a path decomposition as the basis for a linear-time algorithm to decide if a graph has a crossing-free h-layer drawing (for fixed h). This algorithm is extended to solve related problems, including allowing at most k crossings, or removing at most r edges to leave a crossing-free drawing (for fixed k or r). If the number of crossings or deleted edges is a non-fixed parameter then these problems are NP-complete. For each setting, we can also permit downward drawings of directed graphs and drawings in which edges may span multiple layers, in which case either the total span or the maximum span of edges can be minimized. In contrast to the Sugiyama method for layered graph drawing, our algorithms do not assume a preassignment of the vertices to layers.

On the Parameterized Complexity of Layered Graph Drawing

We present the first results on the parameterized complexity of reconfiguration problems, where a reconfiguration variant of an optimization problem $$\mathcal {Q}$$Q takes as input two feasible solutions S and T and determines if there is a sequence of reconfiguration steps, ie a reconfiguration sequence, that can be applied to transform S into T such that each step results in a feasible solution to $$\mathcal {Q}$$Q For most of the results in this paper, S and T are sets of vertices of a given graph and a reconfiguration step adds or removes a vertex Our study is motivated by results establishing that for many NP-hard problems, the classical complexity of reconfiguration is PSPACE-complete We address the question for several important graph properties under two natural parameterizations: k, a bound on the size of solutions, and $$\ell $$l, a bound on the length of reconfiguration sequences Our first general result is an algorithmic paradigm, the reconfiguration kernel, used to obtain fixed-parameter tractable algorithms for reconfiguration variants of Vertex Cover and, more generally, Bounded Hitting Set and Feedback Vertex Set, all parameterized by k In contrast, we show that reconfiguring Unbounded Hitting Set is W[2]-hard when parameterized by $$k+\ell $$k+l We also demonstrate the W[1]-hardness of reconfiguration variants of a large class of maximization problems parameterized by $$k+\ell $$k+l, and of their corresponding deletion problems parameterized by $$\ell $$l; in doing so, we show that there exist problems in FPT when parameterized by k, but whose reconfiguration variants are W[1]-hard when parameterized by $$k+\ell $$k+l

Naomi Nishimura

Papers

Introduction to Reconfiguration

Detecting Backdoor Sets with Respect to Horn and Binary Clauses.

On Graph Powers for Leaf-Labeled Trees

On the Parameterized Complexity of Layered Graph Drawing

On the Parameterized Complexity of Reconfiguration Problems