The use of annotations, referred to as assertions or contracts, to describe program properties for which run-time tests are to be generated, has become frequent in dynamic programing languages. However, the frameworks proposed to support such run-time testing generally incur high time and/or space overheads over standard program execution. We present an approach for reducing this overhead that is based on the use of memoization to cache intermediate results of check evaluation, avoiding repeated checking of previously verified properties. Compared to approaches that reduce checking frequency, our proposal has the advantage of being exhaustive (i.e., all tests are checked at all points) while still being much more efficient than standard run-time checking. Compared to the limited previous work on memoization, it performs the task without requiring modifications to data structure representation or checking code. While the approach is general and system-independent, we present it for concreteness in the context of the Ciao run-time checking framework, which allows us to provide an operational semantics with checks and caching. We also report on a prototype implementation and provide some experimental results that support that using a relatively small cache leads to significant decreases in run-time checking overhead.

Self-organizing software systems are an increasingly attractive approach to highly distributed, decentralized, dynamic applications. In some domains (such as the Internet), the interaction of originally independent systems yields a self-organizing system de facto, and engineers must take these characteristics into account to manage them. This review surveys current work in this field and outlines its main themes, identifies challenges for future research, and addresses the continuity between software engineering in general and techniques appropriate for self-organizing systems.

This paper studies the relation between two recent extensions of propositional Equilibrium Logic, a well-known logical characterisation of Answer Set Programming. In particular, we show how Temporal Equilibrium Logic, which introduces modal operators as those typically handled in Linear-Time Temporal Logic (LTL), can be encoded into Infinitary Equilibrium Logic, a recent formalisation that allows the use of infinite conjunctions and disjunctions. We prove the correctness of this encoding and, as an application, we further use it to show that the semantics of the temporal logic programming formalism called TEMPLOG is subsumed by Temporal Equilibrium Logic.

Partial functions are common abstractions in formal specification notations such as Z, B and Alloy. Conversely, executable programming languages usually provide little or no support for them. In this paper we propose to add partial functions as a primitive feature to a Constraint Logic Programming (CLP) language, namely {log}. Although partial functions could be programmed on top of {log}, providing them as first-class citizens adds valuable flexibility and generality to the form of set-theoretic formulas that the language can safely deal with. In particular, the paper shows how the {log} constraint solver is naturally extended in order to accommodate for the new primitive constraints dealing with partial functions. Efficiency of the new version is empirically assessed by running a number of non-trivial set-theoretical goals involving partial functions, obtained from specifications written in Z.

The 31st edition of the International Conference of Logic Programming (ICLP 2015) took place in Cork, Ireland, from 31 August 2015 to 4 September 2015, co-located with the 21st International Conference on Principles and Practice of Constraint Programming (CP 2015) and part of George Boole 200, a celebration of the life and work of George Boole who was born in 1815 and worked at the University College of Cork.

The design of efficient solutions for abstract argumentation problems is a crucial step towards advanced argumentation systems. One of the most prominent approaches in the literature is to use Answer-Set Programming (ASP) for this endeavor. In this paper, we present new encodings for three prominent argumentation semantics using the concept of conditional literals in disjunctions as provided by the ASP-system clingo. Our new encodings are not only more succinct than previous versions, but also outperform them on standard benchmarks.

Fuzzy answer set programming (FASP) combines two declarative frameworks, answer set programming and fuzzy logic, in order to model reasoning by default over imprecise information. Several connectives are available to combine different expressions; in particular the Gödel and Łukasiewicz fuzzy connectives are usually considered, due to their properties. Although the Gödel conjunction can be easily eliminated from rule heads, we show through complexity arguments that such a simplification is infeasible in general for all other connectives. The paper analyzes a translation of FASP programs into satisfiability modulo theories (SMT), which in general produces quantified formulas because of the minimality of the semantics. Structural properties of many FASP programs allow to eliminate the quantification, or to sensibly reduce the number of quantified variables. Indeed, integrality constraints can replace recursive rules commonly used to force Boolean interpretations, and completion subformulas can guarantee minimality for acyclic programs with atomic heads. Moreover, head cycle free rules can be replaced by shifted subprograms, whose structure depends on the eliminated head connective, so that ordered completion may replace the minimality check if also Łukasiewicz disjunction in rule bodies is acyclic. The paper also presents and evaluates a prototype system implementing these translations.

Tabling is probably the most widely studied extension of Prolog. But despite its importance and practicality, tabling is not implemented by most Prolog systems. Existing approaches require substantial changes to the Prolog engine, which is an investment out of reach of most systems. To enable more widespread adoption, we present a new implementation of tabling in under 600 lines of Prolog code. Our lightweight approach relies on delimited control and provides reasonable performance.

This paper defines the syntax and semantics of the input language of the ASP grounder gringo. The definition covers several constructs that were not discussed in earlier work on the semantics of that language, including intervals, pools, division of integers, aggregates with non-numeric values, and lparse-style aggregate expressions. The definition is abstract in the sense that it disregards some details related to representing programs by strings of ASCII characters. It serves as a specification for gringo from Version 4.5 on.

Many recent analyses for conventional imperative programs begin by transforming programs into logic programs, capitalising on existing LP analyses and simple LP semantics. We propose using logic programs as an intermediate program representation throughout the compilation process. With restrictions ensuring determinism and single-modedness, a logic program can easily be transformed to machine language or other low-level language, while maintaining the simple semantics that makes it suitable as a language for program analysis and transformation. We present a simple LP language that enforces determinism and single-modedness, and show that it makes a convenient program representation for analysis and transformation.

The supertree construction problem is about combining several phylogenetic trees with possibly conflicting information into a single tree that has all the leaves of the source trees as its leaves and the relationships between the leaves are as consistent with the source trees as possible. This leads to an optimization problem that is computationally challenging and typically heuristic methods, such as matrix representation with parsimony (MRP), are used. In this paper we consider the use of answer set programming to solve the supertree construction problem in terms of two alternative encodings. The first is based on an existing encoding of trees using substructures known as quartets, while the other novel encoding captures the relationships present in trees through direct projections. We use these encodings to compute a genus-level supertree for the family of cats (Felidae). Furthermore, we compare our results to recent supertrees obtained by the MRP method.

With the significant advances in the area of autonomous agents and multi-agent systems in the last decade, promising technologies for the development and engineering of multi-agent systems have emerged. The result is a variety of agent-oriented programming languages, development frameworks, execution platforms, and tools that facilitate building and engineering of multi-agent systems. This paper provides an overview of the multi-agent programming research field and explains the aim and characteristics of various multi-agent programming languages and development frameworks. This overview is complemented with a discussion on the current trends and challenges in this research community.

This paper introduces a new logic-based method for optimising the selection of compiler flags on embedded architectures. In particular, we use Inductive Logic Programming (ILP) to learn logical rules that relate effective compiler flags to specific program features. Unlike earlier work, we aim to infer human-readable rules and we seek to develop a relational first-order approach which automatically discovers relevant features rather than relying on a vector of predetermined attributes. To this end we generated a data set by measuring execution times of 60 benchmarks on an embedded system development board and we developed an ILP prototype which outperforms the current state-of-the-art learning approach in 34 of the 60 benchmarks. Finally, we combined the strengths of the current state of the art and our ILP method in a hybrid approach which reduced execution times by an average of 8% and up to 50% in some cases.

For many years, the progress in agent-oriented development has focused on tools and methods for particular development phases. This has not been enough for the industry to accept agent technology as we expected. Our hypothesis is that the Agent-Oriented Software Engineering (AOSE) community has not recognized the kind of development methods that industry actually demands. We propose to analyze this hypothesis starting with a more precise definition of what an AOSE methodology should be. This definition is the first step for a review of the current progress of an illustrative selection of methodologies, looking for missing elements and future lines of improvement. The result is an account of how well the AOSE community is meeting the software lifecycle needs. It can be advanced that AOSE methodologies are far from providing all the answers industry requires and that effort has grounded mainly in requirements, design, and implementation phases.

This paper describes Picat's planner, its implementation, and planning models for several domains used in International Planning Competition (IPC) 2014. Picat's planner is implemented by use of tabling. During search, every state encountered is tabled, and tabled states are used to effectively perform resource-bounded search. In Picat, structured data can be used to avoid enumerating all possible permutations of objects, and term sharing is used to avoid duplication of common state data. This paper presents several modeling techniques through the example models, ranging from designing state representations to facilitate data sharing and symmetry breaking, encoding actions with operations for efficient precondition checking and state updating, to incorporating domain knowledge and heuristics. Broadly, this paper demonstrates the effectiveness of tabled logic programming for planning, and argues the importance of modeling despite recent significant progress in domain-independent PDDL planners.

Lateral-pendulum unicycle robot is a type of single-wheeled mobile robot which utilizes an inverted pendulum mounted laterally for its stabilization and control. Even though this concept was first mentioned in the 1980s, it has not been sufficiently explored especially from the theoretical point of view. Therefore, this robot represents a niche which is still open for more thorough research. This paper presents four contributions to the research of this particular robot. First, the complete model of the robot dynamics is derived and this model can facilitate more accurate study of the robot's static and dynamic behaviors. Secondly, two important constants namely (1) lateral-statics boundary and (2) lateral-statics constant, which are useful for the lateral stabilization, are derived and analyzed. Thirdly, turning constant, required for the control of the turning motion, is derived and used to study the achievable path curvature in maneuvering control. Lastly, dynamics couplings during steady linear motion and steady circular motion are studied and the necessity of integral action in the lateral controller for circular motion is shown and explained. Throughout this paper, numerical simulation is used intensively and two case studies are presented to illustrate the concepts.

Product configuration is when an artifact from a product family is assembled from a set of predefined components that can only be combined in certain ways. These ways are defined by configuration rules. The product developers inspect the configuration rules when they develop new configuration rules or modify the configuration rules set. The inspection of configuration rules is thereby an important activity to avoid errors in the configuration rules set. Several formulations of constraint satisfaction problems (CSPs) are proposed that facilitate the inspection of configuration rules in propositional logic (IF-THEN, AND, NOT, OR, etc.). Many of the configuration rules are so called production rules; that is, a configuration rule is an IF-THEN expression that fires when the IF condition is met. Several configuration rules build chains that fire during the product configuration. It is therefore important not only to inspect single configuration rules but also to analyze the effect of multiple configuration rules. Formulating the tasks as variations of the CSP can support the inspection activity. More specifically, we address the reformulation of configuration rules, testing of feature variant combinations, and counting of item quantities from an item set. The suggested CSPs are tested on industrial vehicle configuration rules for computational performance. The results show that the time for achieving results from the solving of the CSP is within seconds. Our future work will be to implement the various CSPs into a demonstrator that could be tested by product developers.

This article presents a modeling and parametric investigation of printed circuit board (PCB) coils used in inductive power charging systems by using intensive full-wave electromagnetic simulations. Low frequencies applications (below 1 MHz) are targeted. The proposed modeling approach and design methodology are validated for wireless power transfer systems including transmitting (Tx) and receiving (Rx) coils. The impact of ferrite materials used for shielding and efficiency improvement is also analyzed. Optimized PCB coils allowing a theoretical efficiency of 88.7% at 100 kHz and 98.5% at 1 MHz confirms that PCB coils are appropriate for wireless power transfer at such frequencies.