Logic Programming Applications: What Are the Abstractions and Implementations?

This article presents an overview of applications of logic programming, classifying them based on the abstractions and implementations of logic languages that support the applications. The three key abstractions are join, recursion, and constraint. Their essential implementations are for-loops, fixed points, and backtracking, respectively. The corresponding kinds of applications are database queries, inductive analysis, and combinatorial search, respectively. We also discuss language extensions and programming paradigms, summarize example application problems by application areas, and touch on example systems that support variants of the abstractions with different implementations

Why join a team?

We present experiments exploring why high ability workers join teams with less able co-workers when there are no short-term financial benefits. We distinguish between two explanations: pro-social preferences and expected long-term financial gains from teaching future teammates. Participants perform a real-effort task and decide whether to work independently or join a two-person team. Treatments vary the payment scheme (piece rate or revenue sharing), whether teammates can communicate, and the role of teaching. High ability workers are more willing to join teams in the absence of revenue sharing and less willing to join teams when they cannot communicate. When communication is possible, the choice of high ability workers to join teams is driven by expected future financial gains from teaching rather than some variety of pro-social preferences. This result has important implications for the role of adverse selection in determining the productivity of teams

Exploiting Global Constraints for Search and Propagation

Résumé Cette thèse se concentre sur la Programmation par contraintes (PPC), qui est un paradigme émergent pour résoudre des problèmes complexes d’optimisation combinatoire. Les principales contributions tournent autour du filtrage des contraintes et de la recherche; les deux sont des composantes cl´e dans la résolution de problèmes complexes à travers la PPC. D’un côté, le filtrage des contraintes permet de réduire la taille de l’espace de recherche, d’autre part, la recherche définit la manière dont cet espace sera exploré. Les progrès sur ces sujets sont essentiels pour élargir l’applicabilité de CP à des problèmes réels. En ce qui concerne le filtrage des contraintes, les contributions sont les suivantes: premièrement, on propose une amélioration sur un algorithme existant de la version relaxée d’une contrainte commune qui apparaît souvent dans les problèmes d’affectation (soft gcc). L’algorithme proposé améliore en termes de complexité soit pour la cohérence, soit pour le filtrage et en termes de facilité d’implémentation. Deuxièmement, on introduit une nouvelle contrainte (soit dure soit relaxée) et les algorithmes de filtrage pour une sous-structure récurrente qui se produit dans les problèmes d’affectation des ressources hétérogènes (hierarchical gcc). Nous montrons des résultats encourageants par rapport à une d´écomposition équivalente basée sur gcc. En ce qui concerne la recherche, nous présentons tout d’abord les algorithmes pour compter le nombre de solutions pour deux importantes familles de contraintes: les contraintes sur les occurrences, par exemple, alldifferent, symmetric alldifferent et gcc, et les contraintes de séquence admissible, telles que regular. Ces algorithmes sont à la base d’une nouvelle famille d’heuristiques de recherche, centrées sur les contraintes et basées sur le d´énombrement. Ces heuristiques extraient des informations sur le nombre de solutions des contraintes, pour guider la recherche vers des parties de l’espace de recherche qui contiennent probablement un grand nombre de solutions. Les résultats expérimentaux sur huit différents problèmes montrent une performance impressionnante par rapport à l’état de l’art des heuristiques génériques. Enfin, nous expérimentons une forme forte, déjà connue, de filtrage qui est guidée par la recherche (quick shaving). Cette technique donne des résultats soit encourageants soit mauvais lorsqu’elle est appliquée aveuglément à tous les problèmes. Nous avons introduit un estimateur simple mais très efficace pour activer ou désactiver dynamiquement le quick shaving; de tests expérimentaux ont montré des résultats très prometteurs.----------Abstract This thesis focuses on Constraint Programming (CP), that is an emergent paradigm to solve complex combinatorial optimization problems. The main contributions revolve around constraint filtering and search that are two main components of CP. On one side, constraint filtering allows to reduce the size of the search space, on the other, search defines how this space will be explored. Advances on these topics are crucial to broaden the applicability of CP to real-life problems. For what concerns constraint filtering, the contribution is twofold: we firstly propose an improvement on an existing algorithm of the relaxed version of a constraint that frequently appears in assignment problems (soft gcc). The algorithm proposed outperforms the previously known in terms of time-complexity both for the consistency check and for the filtering and in term of ease of implementiation. Secondly, we introduce a new constraint (both hard and soft version) and associated filtering algorithms for a recurrent sub-structure that occurs in assignment problems with heterogeneous resources (hierarchical gcc). We show promising results when compared to an equivalent decomposition based on gcc. For what concerns search, we introduce algorithms to count the number of solutions for two important families of constraints: occurrence counting constraints, such as alldifferent, symmetric alldifferent and gcc, and sequencing constraints, such as regular. These algorithms are the building blocks of a new family of search heuristics, called constraint-centered counting-based heuristics. They extract information about the number of solutions the individual constraints admit, to guide search towards parts of the search space that are likely to contain a high number of solutions. Experimental results on eight different problems show an impressive performance compared to other generic state-of-the-art heuristics. Finally, we experiment on an already known strong form of constraint filtering that is heuristically guided by the search (quick shaving). This technique gives mixed results when applied blindly to any problem. We introduced a simple yet very effective estimator to dynamically disable quick shaving and showed experimentally very promising results

Improvement and Integration of Counting-Based Search Heuristics in Constraint Programming

Ce mémoire s’intéresse à la programmation par contraintes, un paradigme pour résoudre des problèmes combinatoires. Pour la plupart des problèmes, trouver une solution n’est pas possible si on se limite à des mécanismes d’inférence logique; l’exploration d’un espace des solutions à l’aide d’heuristiques de recherche est nécessaire. Des nombreuses heuristiques existantes, les heuristiques de branchement basées sur le dénombrement seront au centre de ce mémoire. Cette approche repose sur l’utilisation d’algorithmes pour estimer le nombre de solutions des contraintes individuelles d’un problème de satisfaction de contraintes. Notre contribution se résume principalement à l’amélioration de deux algorithmes de dénombrement pour les contraintes alldifferent et spanningTree; ces contraintes peuvent exprimer de nombreux problèmes de satisfaction, et sont par le fait même essentielles à nos heuristiques de branchement. Notre travail fait également l’objet d’une contribution à un solveur de programmation par contraintes open-source. Ainsi, l’ensemble de ce mémoire est motivé par cette considération pratique; nos algorithmes doivent être accessibles et performants. Finalement, nous explorons deux techniques applicables à l’ensemble de nos heuristiques: une technique qui réutilise des calculs précédemment faits dans l’arbre de recherche ainsi qu’une manière d’apprendre de nouvelles heuristiques de branchement pour un problème.=----------ABSTRACT: This thesis concerns constraint programming, a paradigm for solving combinatorial problems. The focus is on the mechanism involved in making hypotheses and exploring the solution space towards satisfying solutions: search heuristics. Of interest to us is a specific family called counting-based search, an approach that uses algorithms to estimate the number of solutions of individual constraints in constraint satisfaction problems to guide search. The improvements of two existing counting algorithms and the integration of counting-based search in a constraint programming solver are the two main contributions of this thesis. The first counting algorithm concerns the alldifferent constraint; the second one, the spanningTree constraint. Both constraints are useful for expressing many constraint satisfaction problems and thus are essential for counting-based search. Practical matters are also central to this work; we integrated counting-based search in an open-source constraint programming solver called Gecode. In doing so, we bring this family of search heuristics to a wider audience; everything in this thesis is built upon this contribution. Lastly, we also look at more general improvements to counting-based search with a method for trading computation time for accuracy, and a method for learning new counting-based search heuristics from past experiments

Practical synthesis from real-world oracles

As software systems become increasingly heterogeneous, the ability of compilers to reason about an entire system has decreased. When components of a system are not implemented as traditional programs, but rather as specialised hardware, optimised architecture-specific libraries, or network services, the compiler is unable to cross these abstraction barriers and analyse the system as a whole. If these components could be modelled or understood as programs, then the compiler would be able to reason about their behaviour without concern for their internal implementation details: a homogeneous view of the entire system would be afforded. However, it is not often the case that such components ever corresponded to an original program. This means that to facilitate this homogenenous analysis, programmatic models of component behaviour must be learned or constructed automatically. Constructing these models is an inductive program synthesis problem, albeit a challenging one that is largely beyond the ability of existing implementations. In order for the problem to be made tractable, information provided by the underlying context (i.e. the real component behaviour to be matched) must be integrated. This thesis presents three program synthesis approaches that integrate contextual information to synthesise programmatic models for real, existing components. The first, Annote, exploits informally-encoded information about a component's interface (e.g. from documentation) by weaving that information into an extended type-and-attribute system for component interfaces. The second, Presyn, learns a pair of cooperating probabilistic models from prior syntheses, that aim to predict likely program structure based on a component's interface. Finally, Haze uses observations of common side-effects of component executions to bias the search for programs. These approaches are each evaluated against comparable synthesisers from the literature, on a set of benchmark problems derived from real components. Learning models for component behaviour is only a partial solution; the compiler must also have some mechanism to use those models for program analysis and transformation. This thesis additionally proposes a novel mechanism for context-sensitive automatic API migration based on synthesised programmatic models, and evaluates the effectiveness of doing so on real application code. In summary, this thesis proposes a new framing for program synthesis problems that target the behaviour of real components, and demonstrates three different potential approaches to synthesis in this spirit. The success of these approaches is evaluated against implementations from the literature, and their results used to drive a novel API migration technique