Deploying language models often requires navigating accuracy vs. performance trade-offs to meet latency constraints while preserving utility. Traditional model distillation reduces size but incurs substantial costs through training separate models. We introduce ModularStarEncoder (MoSE), a 1-billion-parameter multi-exit encoder for code retrieval and classification that employs a novel Self-Distillation mechanism. This approach significantly enhances lower-layer representations, enabling flexible deployment of different model portions with favorable performance trade-offs. Our architecture improves text-to-code and code-to-code search by targeting specific encoder layers as exit heads, where higher layers guide earlier ones during training, thereby improving intermediate representations at minimal additional cost. We further enhance MoSE with a repository-level contextual loss that maximizes training context window utilization. Additionally, we release a new dataset created through code translation that extends text-to code benchmarks with cross-language code-to-code pairs. Evaluations demonstrate the effectiveness of Self-Distillation as a principled approach to trading inference cost for accuracy across various code understanding tasks.

In the wood industry, ensuring the stability and immobility of a workpiece during machining is essential. Vacuum suction cups are commonly used as fixtures, as they can rotate to better conform to the workpiece perimeter. However, this rotational capability introduces additional complexity into fixture placement. This paper addresses the problem of optimally positioning rotatable fixtures by combining two complementary techniques. First, we solve a restricted version of the problem that neglects rotations using a constraint solver, yielding an initial feasible solution. This solution is then refined using a Particle Swarm Optimization algorithm that accounts for rotation. Experimental results show that the quality of the initial solution significantly influences the final placement, and that the proposed approach can effectively support expert operators in making improved decisions.

Anterior cruciate ligament (ACL) rupture remains a leading cause of long-term absence in football and is frequently triggered by sub-optimal mechanics during rapid change-of-direction (COD) manoeuvres. To transform laboratory motion analyses into actionable field feedback, a three-stage pipeline is presented. First, 45 kinematic and kinetic variables recorded from 1,009 youth footballers during COD tests are embedded with t-SNE and clustered by agglomerative clustering (Euclidean distance, Ward linkage), revealing four force-and-control phenotypes aligned with established ACL-risk mechanisms. Second, a Random-Forest classifier recreates these phenotypes from a set of 12 features selected for both importance and ease of capture, achieving a macro-averaged F1 = 0.85 (compared with 0.92 when all 45 variables are used). Third, the classifier is wrapped in a General Data Protection Regulation (GDPR) compliant application that accepts the 12 inputs, instantly assigns the athlete’s phenotype, and displays tailored exercise cues. The pipeline demonstrates that laboratory-grade biomechanics can be condensed into a rapid, interpretable decision-support tool, enabling data-driven ACL injury mitigation in routine sports medicine practice.

This paper introduces Trajectory-Embedded Matryoshka Representation Learning (TE-MRL).This novel framework synergies the capabilities of trajectory representation learning with the adaptability and efficiency of Matryoshka Representation Learning (MRL).TE-MRL is engineered to generate adaptive, multi-granular embeddings that efficiently capture the spatial-temporal dynamics inherent in trajectory data.We evaluate TE-MRL on the Porto dataset, focusing on trajectory similarity and k-nearest trajectory similarity tasks.Our findings demonstrate that TE-MRL preserves critical features such as travel semantics and temporal regularities while it can significantly reduce computational time and memory footprint.The proposed approach matches existing methods' accuracy and efficiency but demonstrates robust adaptability under varying computational constraints.Furthermore, we proposed a two-stage retrieval pipeline to enhance computational time while maintaining the same precision.We reduced the computation time by 8× while maintaining state-of-the-art precision.The effectiveness of TE-MRL in handling the complexity of the Porto dataset underlines its potential for broader applications in urban computing and mobility analytics.

Capturing the intricate dynamics of complex systems often requires integrating time-series data from multiple sources. However, effectively unifying and analyzing these heterogeneous streams poses significant methodological challenges. This work proposes a contrastive dual-encoder framework that learns a shared latent representation across distinct timeseries modalities. By mapping semantically related segments of different data views to proximate regions in the latent space, our approach captures cross-modal dependencies in a manner that traditional single-view models often overlook. We illustrate the framework in a motorcycle riding application, where rider behavior signals (e.g., gear, throttle, braking) are embedded jointly with vehicle dynamics (e.g., speed, lean angle, acceleration). We used real-world data to demonstrate the framework’s utility in uncovering how rider inputs translate into specific vehicle states and vice versa. Beyond validating cross-modal alignment, the learned embeddings facilitate robust downstream analyses, including feature importance via SHAP, rider profiling based on latent-space clustering, and mission profile characterization that links riding objectives to observed patterns. These findings underscore the effectiveness of dual-encoder architectures in enhancing the analysis and interpretation of complex multimodal time-series data.

In the wood industry, workpieces are commonly processed using machines equipped with movable bars and suction cups that serve as fixtures to stabilize the workpiece and reduce vibrations during machining. Optimizing the layout of these fixtures is essential to ensure both stability and high production quality. In collaboration with a manufacturing company, we propose a declarative approach to fixture layout optimization based on Constraint Programming (CP). Our method automatically generates fixture configurations that guarantee workpiece stability while adhering to geometric, safety, and resource constraints. The model is implemented in MiniZinc to offer flexibility and compatibility with various solving technologies. Empirical evaluations on a real-world case study prove that our approach significantly improves both the quality and usability of the company’s existing software tool.

With the increasing popularity of LLM-based code completers, like GitHub Copilot, the interest in automatically detecting AI-generated code is also increasing-in particular in contexts where the use of LLMs to program is forbidden by policy due to security, intellectual property, or ethical concerns. We introduce a novel technique for AI code stylometry, i.e., the ability to distinguish code generated by LLMs from code written by humans, based on a transformer-based encoder classifier. Differently from previous work, our classifier is capable of detecting AI-written code across 10 different programming languages with a single machine learning model, maintaining high average accuracy across all languages (84.1% ± 3.8%). Together with the classifier we also release H-AIRosettaMP, a novel open dataset for AI code stylometry tasks, consisting of 121 247 code snippets in 10 popular programming languages, labeled as either human-written or AI-generated. The experimental pipeline (dataset, training code, resulting models) is the first fully reproducible one for the AI code stylometry task. Most notably our experiments rely only on open LLMs, rather than on proprietary/closed ones like ChatGPT.

In the automotive environment, understanding the thermal behavior of the engine is crucial: a fault in measuring the temperature can reduce reliability and poor fuel efficiency. Internal combustion engine temperature is usually measured using a device called coolant temperature sensor. The sensor may fail, and having an indirect system to get that value can avoid unpleasant conditions. This work addresses a novel solution to estimate the coolant temperature based on machine learning models trained using riding data. This solution can back up the physical sensor and monitor abnormal behavior. We also focused on developing a virtual sensor that would behave well in case of thermal shock, which is essential for ensuring safety, improving the engine work, and making the components last longer. We showed how an approach based on the prediction of the temperature delta is better for dealing with this kind of phenomenon. We obtained an RMSE of 2.79°C training a Long short-term memory (LSTM) on more than 1060$h$recorded from Ducati Multistrada V4.

This paper presents a novel approach to body gesture recognition for powered wheelchair users, leveraging inertial data from wrist-mounted sensors to facilitate movement and enhance autonomy in Adapted Physical Activity (APA). Gesture recognition technology interprets human gestures to allow non-direct communication with devices, enhancing human-machine interaction across various fields. APA fosters inclusion and well-being through tailored physical engagement. Our model not only identifies known gestures with high accuracy, as indicated by a mean Average Precision (mAP) score of 0.92 and a Recall@1 score of 0.983, but also demonstrates the ability to recognize gestures not included in the training set. This research contributes to the field of human-robot interaction by offering a more dynamic and inclusive form of interaction for individuals reliant on powered mobility aids.

Meta-solver approaches exploit many individual solvers to potentially build a better solver. To assess the performance of meta-solvers, one can adopt the metrics typically used for individual solvers (e.g., runtime or solution quality) or employ more specific evaluation metrics (e.g., by measuring how close the meta-solver gets to its virtual best performance). In this paper, based on some recently published works, we provide an overview of different performance metrics for evaluating (meta-)solvers by exposing their strengths and weaknesses.

SUNNY is a k-nearest neighbors based Algorithm Selection (AS) approach that schedules and runs a number of solvers for a given unforeseen problem. In this work we present sunny-as2, an enhancement of SUNNY for generic AS scenarios that advances the original approach with wrapper-based feature selection, neighborhood-size configuration and a greedy approach to speed-up the training phase. Empirical evidence shows that sunny-as2 is competitive w.r.t. state-of-the-art AS approaches.

SUNNY is an Algorithm Selection (AS) technique originally tailored for Constraint Programming (CP). SUNNY is based on the k-nearest neighbors algorithm and enables one 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. 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-as, a prototypical algorithm selector based on SUNNY for ASlib scenarios. A major improvement of sunny-as, called sunny-as2, was then 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, by detailing through several empirical evaluations and by providing new insights. Its current version, built on the top of the preliminary version submitted to OASC, is able to outperform sunny-as and other state-of-the-art AS methods, including those who did not attend the challenge.

In this paper, we propose to exploit the side-tuning framework for multimodal document classification. Side-tuning is a methodology for network adaptation recently introduced to solve some of the problems related to previous approaches. Thanks to this technique it is actually possible to overcome model rigidity and catastrophic forgetting of transfer learning by fine-tuning. The proposed solution uses off-the-shelf deep learning architectures leveraging the side-tuning framework to combine a base model with a tandem of two side networks. We show that side-tuning can be successfully employed also when different data sources are considered, e.g. text and images in document classification. The experimental results show that this approach pushes further the limit for document classification accuracy with respect to the state of the art.

Concurrent Constraint Programming (CCP) is a declarative model for concurrency where agents interact by telling and asking constraints (pieces of information) in a shared store. Some previous works have developed (approximated) declarative debuggers for CCP languages. However, the task of debugging concurrent programs remains difficult. In this paper we define a dynamic slicer for CCP (and other language variants) and we show it to be a useful companion tool for the existing debugging techniques. We start with a partial computation (a trace) that shows the presence of bugs. Often, the quantity of information in such a trace is overwhelming, and the user gets easily lost, since she cannot focus on the sources of the bugs. Our slicer allows for marking part of the state of the computation and assists the user to eliminate most of the redundant information in order to highlight the errors. We show that this technique can be tailored to several variants of CCP, such as the timed language ntcc, linear CCP (an extension of CCPbased on linear logic where constraints can be consumed) and some extensions of CCP dealing with epistemic and spatial information. We also develop a prototypical implementation freely available for making experiments.

Abstract In Constraint Programming, a portfolio solver combines a variety of different constraint solvers for solving a given problem. This fairly recent approach enables to significantly boost the performance of single solvers, especially when multicore architectures are exploited. In this work, we give a brief overview of the portfolio solversunny-cp, and we discuss its performance in the MiniZinc Challenge—the annual international competition for Constraint Programming solvers—where it won two gold medals in 2015 and 2016.

Given a collection of algorithms, the Algorithm Selection (AS) problem consists in identifying which of them is the best one for solving a given problem. The selection depends on a set of numerical features that characterize the problem to solve. In this paper we show the impact of feature selection techniques on the performance of the SUNNY algorithm selector, taking as reference the benchmarks of the AS library (ASlib). Results indicate that a handful of features is enough to reach similar, if not better, performance of the original SUNNY approach that uses all the available features. We also present sunny-as: a tool for using SUNNY on a generic ASlib scenario.

Abstract We propose a timed and soft extension of Concurrent Constraint Programming. The time extension is based on the hypothesis ofbounded asynchrony: The computation takes a bounded period of time and is measured by a discrete global clock. Action prefixing is then considered as the syntactic marker that distinguishes a time instant from the next one. Supported by soft constraints instead of crisp ones,tellandaskagents are now equipped with a preference (or consistency) threshold, which is used to determine their success or suspension. In this paper, we provide a language to describe the agents' behavior, together with its operational and denotational semantics, for which we also prove the compositionality and correctness properties. After presenting a semantics using maximal parallelism of actions, we also describe a version for their interleaving on a single processor (with maximal parallelism for time elapsing). Coordinating agents that need to take decisions on both preference values and time events may benefit from this language.

Abstract Program transformation is an appealing technique which allows to improve run-time efficiency, space-consumption, and more generally to optimize a given program. Essentially, it consists of a sequence of syntactic program manipulations which preserves some kind of semantic equivalence. Unfolding is one of the basic operations used by most program transformation systems and consists of the replacement of a procedure call by its definition. While there is a large body of literature on the transformation and unfolding of sequential programs, very few papers have addressed this issue for concurrent languages. This paper defines an unfolding system for Constraint Handling Rules programs. We define an unfolding rule, show its correctness and discuss some conditions that can be used to delete an unfolded rule while preserving the program meaning. We also prove that, under some suitable conditions, confluence and termination are preserved by the above transformation.

Application Programming Interfaces (APIs) are a standard feature of any application that exposes its functionalities to external invokers. APIs can be composed thus obtaining new programs with new functionalities. However API composition can easily become a frustrating task which often prevents developers from using this possibility when implementing and publishing new applications. This fact is due to several specific features of API composition performed using current technology, such as the need of extensive documentation, the need of protocol integration, security issues and others. In this paper we introduce a view of the API as a Service (APIaaS) layer as a tool which ease the development and deployment of applications based on API compositions, by abstracting communication protocols and message formats. We elicit the desirable features of such a layer and provide a proof-of-concept prototype implemented using a Service Oriented language.

Abstract Within the context of constraint solving, a portfolio approach allows one to exploit the synergy between different solvers in order to create a globally better solver. In this paper we present SUNNY: a simple and flexible algorithm that takes advantage of a portfolio of constraint solvers in order to compute — without learning an explicit model — a schedule of them for solving a given Constraint Satisfaction Problem (CSP). Motivated by the performance reached by SUNNY vs. different simulations of other state of the art approaches, we developedsunny-csp, an effective portfolio solver that exploits the underlying SUNNY algorithm in order to solve a given CSP. Empirical tests conducted on exhaustive benchmarks of MiniZinc models show that the actual performance ofsunny-cspconforms to the predictions. This is encouraging both for improving the power of CSP portfolio solvers and for trying to export them to fields such as Answer Set Programming and Constraint Logic Programming.

Software product line development refers to software engineering practices and techniques for creating families of similar software systems from a basic set of reusable components, called shared assets. Teaching how to deal with software product lines in a university lab course is a challenging task, because there are several practical issues that have to be solved in short time. In this paper we report an experience of ours, showing how in the context of a software engineering course at University of Bologna our students tackled the task of developing a software product line consisting of four products which were variants of a basic shared asset. The main idea is that the laboratory activities performed by our students followed the rules of a role-playing game. We describe this experience, defining the role-playing game by a meta-model which abstracts the notion of software process, and we show how we enacted the process for a software product line.

Constraint Handling Rules (CHR) is a committed-choice declarative language that has been originally designed for writing constraint solvers and is nowadays a general purpose language. CHR programs consist of multiheaded guarded rules which allow to rewrite constraints into simpler ones until a solved form is reached. Many empirical evidences suggest that multiple heads augment the expressive power of the language, however no formal result in this direction has been proved, so far. In the first part of this article we analyze the Turing completeness of CHR with respect to the underlying constraint theory. We prove that if the constraint theory is powerful enough then restricting to single head rules does not affect the Turing completeness of the language. On the other hand, differently from the case of the multiheaded language, the single head CHR language is not Turing powerful when the underlying signature (for the constraint theory) does not contain function symbols. In the second part we prove that, no matter which constraint theory is considered, under some reasonable assumptions it is not possible to encode the CHR language (with multi-headed rules) into a single headed language while preserving the semantics of the programs. We also show that, under some stronger assumptions, considering an increasing number of atoms in the head of a rule augments the expressive power of the language. These results provide a formal proof for the claim that multiple heads augment the expressive power of the CHR language.

Abstract We study the decidability of termination for two CHR dialects which, similarly to the Datalog like languages, are defined by using a signature which does not allow function symbols (of arity > 0). Both languages allow the use of the = built-in in the body of rules, thus are built on a host language that supports unification. However each imposes one further restriction. The first CHR dialect allows onlyrange-restrictedrules, that is, it does not allow the use of variables in the body or in the guard of a rule if they do not appear in the head. We show that the existence of an infinite computation is decidable for this dialect. The second dialect instead limits the number of atoms in the head of rules to one. We prove that in this case, the existence of a terminating computation is decidable. These results show that both dialects are strictly less expressive1than Turing Machines. It is worth noting that the language (without function symbols) without these restrictions is as expressive as Turing Machines.

Constraint Handling Rules (CHR) is a committed-choice declarative language which has been originally designed for writing constraint solvers and which is nowadays a general purpose language.

In this paper we investigate the expressive power of three alternative approaches to the definition of infinite behaviours in process calculi, namely, recursive definitions, replication and iteration. We prove several results discriminating between the calculi obtained from a core CCS by adding the three mechanisms mentioned above. These results are derived by considering the decidability of four basic properties: termination (that is, all computations are finite); convergence (that is, the existence of a finite computation); barb (that is, the ability to perform an action on a given channel) and weak bisimulation. Our results, which are summarised in Table 1, show that the three calculi form a strict expressiveness hierarchy in that: all the properties mentioned are undecidable in CCS with recursion; only termination and barb are decidable in CCS with replication; all the properties are decidable in CCS with iteration. As a corollary, we also obtain a strict expressiveness hierarchy with respect to weak bisimulation, since there exist weak bisimulation preserving encodings of iteration in replication and of replication in recursion, whereas there are no weak bisimulation preserving encodings in the other directions.

Constraint Handling Rules (CHR) is a committed-choice declarative language which has been designed for writing constraint solvers. A CHR program consists of multiheaded guarded rules which allow to rewrite constraints into simpler ones until a solved form is reached. CHR has received considerable attention, both from the practical and from the theoretical side. Nevertheless, due the use of multiheaded clauses, there are several aspects of the CHR semantics which have not been clarified yet. In particular, no compositional semantics for CHR has been defined so far. In this article we introduce a fix-point semantics which characterizes the input/output behavior of a CHR program and which is and-compositional, that is, which allows to retrieve the semantics of a conjunctive query from the semantics of its components. Such a semantics can be used as a basis to define incremental and modular analysis and verification tools.

Program transformation is an appealing technique which allows to improve run-time efficiency, space-consumption and more generally to optimize a given program. Essentially it consists of a sequence of syntactic program manipulations which preserves some kind of semantic equivalence. One of the basic operations which is used by most program transformation systems is unfolding which consists in the replacement of a procedure call by its definition. While there is a large body of literature on transformation and unfolding of sequential programs, very few papers have addressed this issue for concurrent languages and, to the best of our knowledge, no one has considered unfolding of CHR programs.

This special issue is inspired by the homonymous ICLP workshops that took place during ICLP 2001 and ICLP 2002. Extending and shifting slightly from the scope of their predecessors (on verification and logic languages) held in the context of previous editions of ICLP, the aim of the SAVE workshops was to bring together researchers interested in the use of computational logic as a tool for the specification, the analysis and the validation of systems, with particular emphasis on emerging technologies such as World Wide Web and E-Commerce, (protocols for) Smart Cards and Mobile Telephony, Wireless Technology, Hybrid Systems, Real-Time and Distributed systems, etc.

Constraint Handling Rules (CHR) are a committed-choice declarative language which has been designed for writing constraint solvers. A CHR program consists of multi-headed guarded rules which allow one to rewrite constraints into simpler ones until a solved form is reached.CHR has received a considerable attention, both from the practical and from the theoretical side. Nevertheless, due the use of multi-headed clauses, there are several aspects of the CHR semantics which have not been clarified yet. In particular, no compositional semantics for CHR has been defined so far.In this paper we introduce a fix-point semantics which characterizes the input/output behavior of a CHR program and which is and-compositional, that is, which allows to retrieve the semantics of a conjunctive query from the semantics of its components. Such a semantics can be used as a basis to define incremental and modular analysis and verification tools.

A temporal logic is presented for reasoning about the correctness of timed concurrent constraint programs. The logic is based on modalities which allow one to specify what a process produces as a reaction to what its environment inputs. These modalities provide an assumption/commitment style of specification which allows a sound and complete compositional axiomatization of the reactive behavior of timed concurrent constraint programs.

In [5] we introduced a Timed Linda language (T-Linda) whic hwas obtained by a natural timed interpretation of the usual constructs of the Linda model and by including a simple primitive for specifying time-outs. Here we define a denotational model for T-Linda which is based on timed reactive sequences. The correctness of this model is proved w.r.t a notion of observ ables which include finite traces of actions and input/output pairs.

A temporal logic is presented for reasoning about the correctness of timed concurrent constraint programs. The logic is based on epistemic modalities which express either what a process knows at a certain time or what a process believes about the results of the other processes. In terms of these epistemic modalities of knowledge and belief a compositional axiomatization is given of the reactive behaviour of timed concurrent constraint programs.

We introduce a transformation system for concurrent constraint programming (CCP). We define suitable applicability conditions for the transformations that guarantee the input/output CCP semantics is also preserved when distinguishing deadlocked computations from successful ones and when considering intermediate results of (possibly) nonterminating computations.The system allows us to optimize CCP programs while preserving their intended meaning: In addition to the usual benefits for sequential declarative languages, the transformation of concurrent programs can also lead to the elimination of communication channels and of synchronization points, to the transformation of nondeterministic computations into deterministic ones, and to the crucial saving of computational space. Furthermore, since the transformation system preserves the deadlock behavior of programs, it can be used for proving deadlock-freeness of a given program with respect to a class of queries. To this aim, it is sometimes sufficient to apply our transformations and to specialize the resulting program with respect to the given queries in such a way that the obtained program is trivially deadlock-free.

In this paper we study unfold/fold transformations for constraint logic programs (CLP) with dynamic scheduling and for concurrent constraint programming (CCP). We define suitable applicability conditions for these transformations which guarantee that the original and the transformed program have the same results of successful derivations and the same deadlock free queries.The possible applications of these results are twofold. On one hand we can use the unfold/fold system to optimize CLP and CCP programs while preserving their intended meaning and in particular without the risk of introducing deadlocks. On the other hand, unfold/fold transformations can be used for proving deadlock freeness of a class of queries in a given program: to this aim it is sufficient to apply our transformations and to specialize the resulting program with respect to the given queries in such a way that the obtained program is trivially deadlock free. As shown by several interesting examples, this yields a methodology for proving deadlock freeness which is simple and powerful at the same time.

We introduce a simple compositional proof system for proving (partial) correctness of concurrent constraint programs (CCP). The proof system is based on a denotational approximation of the strongest postcondition semantics of CCP programs. The proof system is proved to be correct for full CCP and complete for the class of programs in which the denotational semantics characterizes exactly the strongest postcondition. This class includes the so-called confluent CCP, a special case of which is constraint logic programming with dynamic scheduling.

In this paper we study some first-order formulas, called resultants, which can be used to describe in a concise way most of the relevant information associated to SLD-derivations. We first extend to resultants some classical results of logic programming theory. Then we define a fixpoint semantics for Prolog computed resultants, i.e. those formulas which are obtained by considering the leftmost selection rule. Suitable abstractions of such a semantics are then used to model call patterns and partial answers. Finally we show how these results can be generalized to a larger class of selection rules.

In this paper we study the replacement transformation for Constraint Logic Programming modules. We define new applicabihty conditions which guarantee the correctness of the operation also wrt module¿s composition: under this conditions, the original and the transformed modules have the same observable properties also when they are composed with other modules. Furthermore, the applicability y conditions are uot bound to a specific notion of observable. Here we consider three distinct such notions: two of them are operational and are based on the computed constraints; the third one is the algebraic one based on the least model. We show that our transformation method can be applied in any of these distinct contexts, thus providing a parametric approach.

We consider the constraint logic programming paradigm CLP(χ), as defined by Jaffar and Lassez. CLP(χ) integrates a generic computational mechanism based on constraints within the logic programming framework. The paradigm retains the semantic properties of pure logic programs, namely the existence of equivalent operational, model-theoretic and fixpoint semantics. We introduce a framework for defining various semantics, each corresponding to a specific observable property of CLP computations. Each semantics can be defined either operationally (i.e. top-down) or declaratively (i.e. bottom-up). The construction is based on a new notion of interpretation, on a natural extension of the standard notion of model and on the definition of various immediate consequences operators, whose least fixpoints on the lattice of interpretations are models corresponding to various observable properties. We first consider some semantics defined by Jaffar and Lassez and their relations, in terms of correctness and full abstraction, to the equivalences induced on programs by suitable observables. Then we define a fully abstract semantics which models answer constraints. Finally we introduce a semantics for answer constraints which is compositional w.r.t. union of programs. Suitable abstractions of this semantics allow us to obtain correct (in one case fully abstract) semantics for partial answers and call patterns. Our semantic constructions can be taken as the basis for program transformation and (modular) analyses techniques.

We develop a compositional proof-system for the partial correctness of concurrent constraint programs. Soundness and (relative) completeness of the system are proved with respect to a denotational semantics based on the notion of strongest postcondition. The strongest postcondition semantics provides a justification of the declarative nature of concurrent constraint programs, since it allows to view programs as theories in the specification logic.

A framework for the analysis of concurrent constraint programming (CCP) is proposed. The approach is based on simple denotational semantics that approximate the usual semantics in the sense that they give a superset of the input-output relation of a CCP program. Analyses based on these semantics can be easily and efficiently implemented using standard techniques from the analysis of logic programs.>

In this paper we define a compositional semantics for a generalized composition operator on logic programs. Static and dynamic inheritance as well as composition by union of clauses can all be obtained by specializing the general operator. The semantics is based on the notion of differential programs, logic programs annotated with declarations that establish the programs' external interfaces.