Implementation of exponential and parametrized algorithms in the AGAPE project

This technical report describes the implementation of exact and parametrized exponential algorithms, developed during the French ANR Agape during 2010-2012. The developed algorithms are distributed under the CeCILL license and have been written in Java using the Jung graph library.

💡 Research Summary

The technical report documents the design, implementation, and distribution of a suite of exact and parameterized exponential‑time algorithms developed within the French ANR Agape project between 2010 and 2012. The authors set out to turn theoretical results on classic NP‑hard graph problems—such as Maximum Clique, Minimum Vertex Cover, Independent Set, Treewidth, Hamiltonian Path, and related parameterized versions—into a practical, reusable software library. Java was chosen as the implementation language because of its platform independence and mature ecosystem, and the Jung graph library was adopted to provide a flexible, object‑oriented representation of vertices, edges, and graph attributes. Jung’s modular design allowed the developers to focus on algorithmic logic while reusing existing data structures and basic graph operations.

The library is organized around two principal families of algorithms. The first family consists of traditional exact algorithms that guarantee optimal solutions but exhibit exponential worst‑case running times. For each problem, the authors selected state‑of‑the‑art branching strategies, bit‑mask dynamic programming, and branch‑and‑bound techniques. In the Maximum Clique implementation, for example, a coloring‑based upper bound is computed at each node of the search tree, and vertices are ordered by degree to improve pruning efficiency. The second family comprises parameterized algorithms whose complexity is expressed as f(k)·n^O(1), where k is a problem‑specific parameter (treewidth, solution size, path length, etc.). The report explains how kernelization, bounded‑treewidth decomposition, and color‑coding are translated into Java code. The treewidth‑bounded algorithms first compute a tree decomposition, then perform a bottom‑up dynamic programming pass on the decomposition tree, achieving linear‑time performance when the treewidth is small.

From a software‑engineering perspective, the codebase emphasizes modularity and extensibility. All algorithms implement a generic GraphAlgorithm interface; parameterized variants additionally implement ParameterizedAlgorithm<T,P>, where P denotes the parameter type. This hierarchy enables developers to plug new problems or new parameterizations with minimal boilerplate. Supporting utilities handle input validation, automatic logging of execution time and memory consumption, and conversion of results into standard formats (e.g., JSON, CSV). The library also includes a profiling component that records per‑iteration statistics, facilitating empirical analysis and reproducibility.

The distribution is released under the CeCILL license, a French open‑source license compatible with GPL. This choice ensures that academic and industrial users can freely modify, redistribute, and integrate the code while preserving the same licensing terms. The released package contains the full source tree, Javadoc‑generated API documentation, a set of example programs demonstrating typical usage patterns, and a benchmark suite. The benchmark suite evaluates each algorithm on synthetic random graphs, real‑world network datasets, and graphs of varying densities. Results are presented as tables and plots that illustrate scaling behavior, memory footprints, and the impact of parameter values on runtime. These empirical data serve as a practical guide for users to select the most appropriate algorithm for a given instance.

The authors discuss several technical challenges encountered during development. Memory consumption is a primary concern for exponential algorithms because the state space can explode. To mitigate Java’s garbage‑collection overhead, the implementation employs object pooling, compact bit‑set representations, and careful avoidance of temporary object creation. Parallelism is another focus: a subset of the search‑based algorithms is parallelized using Java’s Fork/Join framework, allowing independent sub‑trees of the search space to be explored concurrently on multi‑core processors. Experimental measurements show an average speed‑up of around 30 % on a 4‑core machine, with larger gains on more heavily branched instances.

Finally, the report outlines future work. The authors propose extending compatibility to other graph libraries such as JGraphT, developing an automatic parameter‑estimation layer that selects the best parameterized algorithm without user‑provided k, and exploring GPU acceleration for dynamic‑programming kernels. They also suggest integrating the library into larger combinatorial optimization frameworks and providing bindings for scripting languages (Python, R) to broaden accessibility. In summary, the AGAPE implementation delivers a well‑engineered, openly licensed collection of exact and parameterized exponential algorithms, bridging the gap between theoretical algorithmic research and practical software tools for graph‑based problem solving.