sunny-as2: Enhancing SUNNY for Algorithm Selection

SUNNY is an Algorithm Selection (AS) technique originally tailored for Constraint Programming (CP). SUNNY enables to schedule, from a portfolio of solvers, a subset of solvers to be run on a given CP problem. This approach has proved to be effective for CP problems, and its parallel version won many gold medals in the Open category of the MiniZinc Challenge -- the yearly international competition for CP solvers. In 2015, the ASlib benchmarks were released for comparing AS systems coming from disparate fields (e.g., ASP, QBF, and SAT) and SUNNY was extended to deal with generic AS problems. This led to the development of sunny-as2, an algorithm selector based on SUNNY for ASlib scenarios. A preliminary version of sunny-as2 was submitted to the Open Algorithm Selection Challenge (OASC) in 2017, where it turned out to be the best approach for the runtime minimization of decision problems. In this work, we present the technical advancements of sunny-as2, including: (i) wrapper-based feature selection; (ii) a training approach combining feature selection and neighbourhood size configuration; (iii) the application of nested cross-validation. We show how sunny-as2 performance varies depending on the considered AS scenarios, and we discuss its strengths and weaknesses. Finally, we also show how sunny-as2 improves on its preliminary version submitted to OASC

Trade-off Analysis for SysML Models Using Decision Points and CSPs

The expected benefits of Model-Based System Engineering (MBSE) include assistance to the system designer in finding the set of optimal architectures and making trade-off analysis. Design objectives such as cost, performance and reliability are often conflicting. The SysML-based method OOSEM and the ARCADIA method focus on the design and analysis of one alternative of the system. They freeze the topology and the execution platform before optimization starts. Further, their limitation quickly appears when a large number of alternatives must be evaluated. The paper avoids these problems and improves trade-off analysis in a MBSE approach by combining the SysML modeling language and so-called “decision points”. An enhanced SysML model with decision points shows up alternatives for component redundancy, and instance selection and allocation. The same SysML model is extended with constraints and objective functions using an optimization context and parametric diagrams. Then a representation of a constraint satisfaction multi-criteria objective problem (CSMOP) is generated and solved with a combination of solvers. A demonstrator implements the proposed approach into an Eclipse plug-in; it uses the Papyrus and CSP solvers, both are open-source tools. A case study illustrates the methodology: a mission controller for an Unmanned Aerial Vehicle (UAV) that includes a stereoscopic camera sensor module. Keywords: MBSE, Optimization, SysML, CSP, Papyrus, System engineering, Optimal architecture design, Decision points

Proceedings of the 2022 XCSP3 Competition

This document represents the proceedings of the 2022 XCSP3 Competition. The results of this competition of constraint solvers were presented at FLOC (Federated Logic Conference) 2022 Olympic Games, held in Haifa, Israel from 31th July 2022 to 7th August, 2022.Comment: arXiv admin note: text overlap with arXiv:1901.0183

Revisiting Counting Solutions for the Global Cardinality Constraint

International audienceCounting solutions for a combinatorial problem has been identified as an important concern within the Artificial Intelligence field. It is indeed very helpful when exploring the structure of the solution space. In this context, this paper revisits the computation process to count solutions for the global cardinality constraint in the context of counting-based search. It first highlights an error and then presents a way to correct the upper bound on the number of solutions for this constraint

SAT and CP: Parallelisation and Applications

This thesis is considered with the parallelisation of solvers which search for either an arbitrary, or an optimum, solution to a problem stated in some formal way. We discuss the parallelisation of two solvers, and their application in three chapters.In the first chapter, we consider SAT, the decision problem of propositional logic, and algorithms for showing the satisfiability or unsatisfiability of propositional formulas. We sketch some proof-theoretic foundations which are related to the strength of different algorithmic approaches. Furthermore, we discuss details of the implementations of SAT solvers, and show how to improve upon existing sequential solvers. Lastly, we discuss the parallelisation of these solvers with a focus on clause exchange, the communication of intermediate results within a parallel solver. The second chapter is concerned with Contraint Programing (CP) with learning. Contrary to classical Constraint Programming techniques, this incorporates learning mechanisms as they are used in the field of SAT solving. We present results from parallelising CHUFFED, a learning CP solver. As this is both a kind of CP and SAT solver, it is not clear which parallelisation approaches work best here. In the final chapter, we will discuss Sorting networks, which are data oblivious sorting algorithms, i. e., the comparisons they perform do not depend on the input data. Their independence of the input data lends them to parallel implementation. We consider the question how many parallel sorting steps are needed to sort some inputs, and present both lower and upper bounds for several cases

Using Restarts in Constraint Programming over Finite Domains - An Experimental Evaluation

The use of restart techniques in complete Satisfiability (SAT) algorithms has made solving hard real world instances possible. Without restarts such algorithms could not solve those instances, in practice. State of the art algorithms for SAT use restart techniques, conflict clause recording (nogoods), heuristics based on activity variable in conflict clauses, among others. Algorithms for SAT and Constraint problems share many techniques; however, the use of restart techniques in constraint programming with finite domains (CP(FD)) is not widely used as it is in SAT. We believe that the use of restarts in CP(FD) algorithms could also be the key to efficiently solve hard combinatorial problems. In this PhD thesis we study restarts and associated techniques in CP(FD) solvers. In particular, we propose to including in a CP(FD) solver restarts, nogoods and heuristics based in nogoods as this should improve search algorithms, and, consequently, efficiently solve hard combinatorial problems. We thus intend to: a) implement restart techniques (successfully used in SAT) to solve constraint problems with finite domains; b) implement nogoods (learning) and heuristics based on nogoods, already in use in SAT and associated with restarts; and c) evaluate the use of restarts and the interplay with the other implemented techniques. We have conducted the study in the context of domain splitting backtrack search algorithms with restarts. We have defined domain splitting nogoods that are extracted from the last branch of the search algorithm before the restart. And, inspired by SAT solvers, we were able to use information within those nogoods to successfully help the variable selection heuristics. A frequent restart strategy is also necessary, since our approach learns from restarts

Ordonnancement de tâches sous contraintes sur des métiers à tisser

Dans une usine de production de textile, il y a des métiers à tisser. Ces métiers à tisser peuvent être configurés de différentes façons. Des tâches doivent être exécutées sur ces métiers à tisser et le temps d’exécution d’une tâche est fonction du métier sur lequel elle est effectuée. De plus, chaque tâche est seulement compatible avec les métiers à tisser étant configurés de certaines façons. Un temps de mise en course peut permettre de configurer ou préparer un métier à tisser pour l’exécution d’une tâche. Le temps de mise en course est dépendant de la tâche qui précède et de celle qui suit. Nous souhaitons alors créer un horaire pour minimiser les temps de fabrication et les retards. Toutefois, certaines contraintes doivent être respectées. Lorsque des préparations surviennent sur des métiers différents en même temps, le nombre d’employés doit être suffisant. Un métier ne peut faire qu’une seule action à la fois. L’ordonnancement d’une seule machine est un problème NP-Difficile. Dans ce projet, il faut ordonnancer environ 800 tâches sur 90 machines dans un horizon de deux semaines, tout en respectant les contraintes de personnel. Des évènements stochastiques doivent être pris en compte pour obtenir un meilleur horaire. Le bris d’un fil n’étant pas un évènement rare, l’occurrence des bris est donnée sous la forme d’une loi de Poisson. Nous proposons alors une approche de résolution utilisant une heuristique de branchement basée sur le problème du commis voyageur. Cette approche permet d’obtenir de bonnes solutions pour le problème d’ordonnancement exploré. Les solutions trouvées sont 5 à 30% meilleures en termes de fonction objectif qu’une heuristique semblable à celle utilisée par l’équipe de planification de notre partenaire industriel. Nous présentons aussi un algorithme pour garantir la robustesse d’un horaire. Notre algorithme permet de générer des horaires plus réalistes et qui résistent bien aux évènements imprévus. La combinaison de ces deux pratiques mène à l’intégration et l’utilisation du produit final par notre partenaire industriel.In a textile factory, there are looms. Workers can configure the looms to weave different pieces of textiles. A loom can only weave a piece of textiles if the piece of textiles is compatible with its loom configuration. To change its configuration, a loom requires a setup. The setups are performed manually by workers. There are also sequence-dependent setups to prepare a loom for the upcoming piece of textiles. We wish to minimize the setups duration and the lateness. A solution must satisfy some constraints. The problem is subject to cumulative resources. The quantity of workers simultaneously configuring machines can’t exceed the total number of employees. A loom can only weave a piece of textiles at a time. Scheduling tasks on a single loom is an NP-Hard problem. In this project, we must schedule tasks an average of 800 tasks on 90 looms with a two-week horizon. Stochastic events might occur and must be accounted for. We must design an algorithm to create robust schedules under uncertainty. As a thread breaking during the weaving process isn’t a rare occurrence, a better schedule could greatly impact the performances of a company when applying the schedule to a real situation. We formulate that the number of breaks per task follows a Poisson distribution. First, we propose a branching heuristic based on the traveling salesperson problem in order to leverage computation times. The solutions found are 5 to 30% better according to their objective function than the ones of a greedy heuristic similar to what our industrial partner uses. We also present a filtering algorithm to guarantee robustness of solutions in respect to a confidence level. This algorithm improves robustness and creates more realist schedules. The algorithm is also efficient in computation time by achieving bound consistency in linear time. Combining both these techniques leads to the integration of our research in the decision system of our industrial partner

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