Implementation and Evaluation of Counting-Based Search for Table Constraints in the OscaR Solver

Dans ce mémoire, nous allons nous intéresser à la programmation par contraintes, un outil efficace en ce qui concerne la résolution de problèmes combinatoires. Nous allons nous intéresser aux problèmes utilisant les contraintes table et plus particulièrement leur implémentation compacte qui a été grandement améliorée par l’utilisation de la structure de données «sparse bit set» réversible. Nous contribuerons en créant une heuristique de recherche basée sur le dénombrement utilisant l’information sur les supports des contraintes table. Nous allons implémenter puis évaluer un algorithme de dénombrement sur Oscar, une librairie de résolution de problèmes par contraintes créée pour résoudre les problèmes combinatoires. Nous définirons alors un algorithme pour obtenir les supports et un algorithme pour réaliser une heuristique de recherche utilisant les informations précédentes. Tous ces algorithmes ont un but commun, mettre en place une recherche basée sur le dénombrement. Nous allons expliquer les modifications faites à Oscar et les heuristiques de recherche que nous avons créées dans Oscar. Finalement, nous présenterons nos résultats sur différents exemplaires de problèmes et nous analyserons les résultats comparés à l’état de l’art pour en déduire les améliorations apportées. Nous utiliserons pour cela les algorithmes suivants: dom et dom/deg. L’expérience montrera que notre recherche basée sur le dénombrement est compétitive pour les exemplaires complexes mais qu’elle coûte plus de temps dans certains cas, même si nous avons moins d’échecs.----------ABSTRACT: In this thesis, we work on constraint programming, an efficient approach to solve combinatorial problems. We consider problems using table constraints and in particular the compact table implementation. Reversible sparse bit sets have been used for the compact table implementation recently, and it improves its efficiency. We contribute by making the heuristic search more efficient for such problems by using counting-based search. Counting-based search uses the supports information from the reversible sparse bit set data structure (used to maintain supports in the table constraints). We implement and evaluate our contribution in Oscar, a constraint programming solver to solve combinatorial problems. We explain the modifications we made in Oscar and the heuristic searches we created in Oscar. We define an algorithm to get the supports from table constraints, a variable ordering heuristic search, and a value ordering heuristic search. All of these algorithms work toward the same goal, counting-based search. Finally, we present our results on different instances of problems and analyze the results and improvements. We compare our methods with dom and dom/deg. The experiment shows counting-based search is competitive if the instances are hard and it costs more time in some instances even if we have fewer failures

Certifying Correctness for Combinatorial Algorithms : by Using Pseudo-Boolean Reasoning

Over the last decades, dramatic improvements in combinatorialoptimisation algorithms have significantly impacted artificialintelligence, operations research, and other areas. These advances,however, are achieved through highly sophisticated algorithms that aredifficult to verify and prone to implementation errors that can causeincorrect results. A promising approach to detect wrong results is touse certifying algorithms that produce not only the desired output butalso a certificate or proof of correctness of the output. An externaltool can then verify the proof to determine that the given answer isvalid. In the Boolean satisfiability (SAT) community, this concept iswell established in the form of proof logging, which has become thestandard solution for generating trustworthy outputs. The problem isthat there are still some SAT solving techniques for which prooflogging is challenging and not yet used in practice. Additionally,there are many formalisms more expressive than SAT, such as constraintprogramming, various graph problems and maximum satisfiability(MaxSAT), for which efficient proof logging is out of reach forstate-of-the-art techniques.This work develops a new proof system building on the cutting planesproof system and operating on pseudo-Boolean constraints (0-1 linearinequalities). We explain how such machine-verifiable proofs can becreated for various problems, including parity reasoning, symmetry anddominance breaking, constraint programming, subgraph isomorphism andmaximum common subgraph problems, and pseudo-Boolean problems. Weimplement and evaluate the resulting algorithms and a verifier for theproof format, demonstrating that the approach is practical for a widerange of problems. We are optimistic that the proposed proof system issuitable for designing certifying variants of algorithms inpseudo-Boolean optimisation, MaxSAT and beyond

Making Compact-Table Compact

The compact-table propagator for table constraints appears to be a strong candidate for inclusion into any constraint solver due to its efficiency and simplicity. However, successful integration into a constraint solver based on copying rather than trailing is not obvious: while the underlying bit-set data structure is sparse for efficiency it is not compact for memory, which is essential for a copying solver. The paper introduces techniques to make compact-table an excellent fit for a copying solver. The key is to make sparse bit-sets dynamically compact (only their essential parts occupy memory and their implementation is dynamically adapted during search) and tables shared (their read-only parts are shared among copies). Dynamically compact bit-sets reduce peak memory by 7.2% and runtime by 13.6% on average and by up to 66.3% and 33.2%. Shared tables even further reduce runtime and memory usage. The reduction in runtime exceeds the reduction in memory and a cache analysis indicates that our techniques might also be beneficial for trailing solvers. The proposed implementation has replaced Gecode’s original implementations as it runs on average almost an order of magnitude faster while using half the memory.QC 20181113</p