Abstract StartSet l o g EndSet { l o g } $\{log\}$ (read ‘setlog’) was born as a Constraint Logic Programming (CLP) language where sets and binary relations are first-class citizens, thus fostering set programming. Internally, StartSet l o g EndSet { l o g } $\{log\}$ is a constraint satisfiability solver implementing decision procedures for several fragments of set theory. Hence, StartSet l o g EndSet { l o g } $\{log\}$ can be used as a declarative, set, logic programming language and as an automated theorem prover for set theory. Over time StartSet l o g EndSet { l o g } $\{log\}$ has been extended with some components integrated to the satisfiability solver thus providing a formal verification environment. In this paper we make a comprehensive presentation of this environment which includes a language for the description of state machines based on set theory, an interactive environment for the execution of functional scenarios over state machines, a generator of verification conditions for state machines, automated verification of state machines, and test case generation. State machines are both, programs and specifications; exactly the same code works as a program and as its specification. In this way, with a few additions, a CLP language turned into a seamlessly integrated programming and automated proof system.

In this paper we extend a decision procedure for the Boolean algebra of finite sets with cardinality constraints (ℒ |⋅| ) to a decision procedure for ℒ |⋅| extended with set terms denoting finite integer intervals (ℒ [] ). In ℒ [] interval limits can be integer linear terms including unbounded variables . These intervals are a useful extension because they allow to express non-trivial set operators such as the minimum and maximum of a set, still in a quantifier-free logic. Hence, by providing a decision procedure for ℒ [] it is possible to automatically reason about a new class of quantifier-free formulas. The decision procedure is implemented as part of the { log } (‘setlog’) tool. The paper includes a case study based on the elevator algorithm showing that { log } can automatically discharge all its invariance lemmas, some of which involve intervals.

Abstract This technical note shows how we have combined prescriptive type checking and constraint solving to increase automation during software verification. We do so by defining a type system and implementing a typechecker for $\{log\}$ (read ‘setlog’), a Constraint Logic Programming language and satisfiability solver based on set theory. The constraint solver is proved to be safe w.r.t. the type system. Two industrial-strength case studies are presented where this combination is used with very good results.

Abstract Intensional sets are sets given by a property rather than by enumerating their elements. In a previous work, we have proposed a decision procedure for a first-order logic language which provides restricted intensional sets (RISs), i.e. a sub-class of intensional sets that are guaranteed to denote finite—though unbounded—sets. In this paper, we show how RIS can be exploited as a convenient programming tool also in a conventional setting, namely the imperative O-O language Java. We do this by considering a Java library, called JSetL, that integrates the notions of logical variable, (set) unification and constraints that are typical of constraint logic programming languages into the Java language. We show how JSetL is naturally extended to accommodate for RIS and RIS constraints and how this extension can be exploited; on the one hand, to support a more declarative style of programming and, on the other hand, to effectively enhance the expressive power of the constraint language provided by the library.

Abstract Formal reasoning about finite sets and cardinality is important for many applications, including software verification, where very often one needs to reason about the size of a given data structure. The Constraint Logic Programming tool $$\{ log\} $$ provides a decision procedure for deciding the satisfiability of formulas involving very general forms of finite sets, although it does not provide cardinality constraints. In this paper we adapt and integrate a decision procedure for a theory of finite sets with cardinality into $$\{ log\} $$ . The proposed solver is proved to be a decision procedure for its formulas. Besides, the new CLP instance is implemented as part of the $$\{ log\} $$ tool. In turn, the implementation uses Howe and King’s Prolog SAT solver and Prolog’s CLP(Q) library, as an integer linear programming solver. The empirical evaluation of this implementation based on +250 real verification conditions shows that it can be useful in practice. Under consideration in Theory and Practice of Logic Programming (TPLP)

Abstract $\{log\}$ (‘setlog’) is a satisfiability solver for formulas of the theory of finite sets and finite set relation algebra (FS&RA). As such, it can be used as an automated theorem prover for this theory. $\{log\}$ is able to automatically prove a number of FS&RA theorems, but not all of them. Nevertheless, we have observed that many theorems that $\{log\}$ cannot automatically prove can be divided into a few subgoals automatically dischargeable by $\{log\}$. The purpose of this work is to present a prototype interactive theorem prover (ITP), called $\{log\}$-ITP, providing evidence that a proper integration of $\{log\}$ into world-class ITP’s can deliver a great deal of proof automation concerning FS&RA. An empirical evaluation based on 210 theorems from the TPTP and Coq’s SSReflect libraries shows a noticeable reduction in the size and complexity of the proofs with respect to Coq.

This paper introduces an instantiation of the constraint logic programming scheme called CLP(PolyFD) in which variables take values from finite subsets of the integers and constraints are expressed as equalities, inequalities, and disequalities of polynomials with integer coefficients. Such constra ints, which we call polynomial constraints over finite domains, can be treated effectively by means of a specific solver under the assumption that initial approximations of the domains of variables are available. The proposed solver deals with constraints in a canonical form and it uses the modified Bernstein form of polynomials to detect the satisfiability of constraints. The solver is complete and a preliminary assessment of its performance is reported.

JSetL is a Java library that endows Java with a number of facilities that are intended to support declarative and constraint (logic) programming. In this paper we show how JSetL can be used to support general forms of nondeterministic programming in

Abstract 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.

This special issue of Fundamenta Informaticae contains the revised, extended versions of selected papers presented at the Italian Conference on Computational Logic (Convegno Italiano di Logica Computazionale, CILC 2011) which was held at the University "G.d'Annunzio" of Chieti-Pescara, Italy.This conference was the twenty-sixth edition of the annual meeting organized by the Italian Association for Logic Programming (GULP, Gruppo Ricercatori e Utenti di Logic Programming), which, since its first edition in 1986, constitutes the main Italian forum for researchers, users, and developers to discuss work and exchange ideas on Computational Logic and related areas, such as Artificial Intelligence and Deductive Databases.All these areas had a very significant growth over the last decades and nowadays they all play a crucial role in the fields of Information Processing and Computer Science.The program of the CILC 2011 conference featured thirty papers (twenty-one which had a long presentation and nine which had a short presentation), two invited talks: (i) one by A. Omicini (University of Bologna) on: "Coordination Models and Technologies toward Self-Organising Systems", and (ii) one by F. Spoto (University of Verona) on: "Static Analysis of Java.Can we be logical?", and a tutorial by F. Riguzzi (University of Ferrara) on: "Probabilistic Logic Languages".The quality of the technical contributions and the number of participants (about fifty, most of whom were young researchers) confirm that the Italian Computational Logic community is very lively and active.Some of the presented papers were selected and their authors were invited to submit an improved version for publication in this special issue.The papers accepted in this issue passed two rounds of careful reviews by qualified international referees, to whom we express our deep gratitude for their comments which helped the authors to improve the quality of their papers.

This paper summarizes a constraint solving technique that is used to reason effectively in the scope of a set-based constraint language that supersedes existing finite domain languages. The first part of this paper motivates the presented work and introduces the constraint language, namely the language of Hereditarily Finite Sets (HFS). Then, the proposed constraint solver is detailed in terms of a set of rewrite rules that exploit finite domain reasoning within the HFS language. The proposed solution improves previous work on CLP (SET) [11] by integrating intervals into the constraint system and by providing a new layered architecture for the solver that supports more effective constraint solving strategies. On the other hand, the proposed approach provides enhanced expressivity and flexibility of domain representation than those usually found in existing finite domain constraint solvers.

In recent years, Answer Set Programming has gained popularity as a viable paradigm for applications in knowledge representation and reasoning. This paper presents a novel methodology to compute answer sets of an answer set program. The proposed methodology maintains a bottom-up approach to the computation of answer sets (as in existing systems), but it makes use of a novel structuring of the computation, that originates from the non-ground version of the program. Grounding is lazily performed during the computation of the answer sets. The implementation has been realized using Constraint Logic Programming over finite domains.

Lists, multisets, and sets are well-known data structures whose usefulness is widely recognized in various areas of computer science. They have been analyzed from an axiomatic point of view with a parametric approach in Dovier et al. [1998], where the relevant unification algorithms have been developed. In this article, we extend these results considering more general constraints, namely, equality and membership constraints and their negative counterparts.

Abstract In this paper we present a Java library—called JSetL—that offers a number of facilities to support declarative programming such as those usually found in logic or functional declarative languages: logical variables, list and set data structures (possibly partially specified), unification and constraint solving over sets, non‐determinism. The paper describes the main features of JSetL and it shows, through a number of simple examples, how these features can be exploited to support a real declarative programming style in Java. Copyright © 2006 John Wiley & Sons, Ltd.

The unification problem in algebras capable of describing sets has been tackled, directly or indirectly, by many researchers and it finds important applications in various research areas, e.g. deductive databases, theorem proving, static analysis, rapid software prototyping. The various solutions proposed are spread across a large literature. In this paper we provide a uniform presentation of unification of sets, formalizing it at the level of set theory. We address the problem of deciding existence of solutions at an abstract level. This provides also the ability to classify different types of set unification problems. Unification algorithms are uniformly proposed to solve the unification problem in each of such classes. The algorithms presented are partly drawn from the literature – and properly revisited and analyzed – and partly novel proposals. In particular, we present a new goal-driven algorithm for general unification.

In this paper we propose a semantically well-founded combination of the constraint solvers used in the constraint programming languages CLP(SET) and CLP(FD). This work demonstrates that it is possible to provide efficient executions (through CLP(FD) solvers) while maintaining the expressive power and flexibility of the CLP(SET) language. We develop a combined constraint solver and we show how static analysis can help in organizing the distribution of constraints to the two constraint solvers.

In this paper we present a study of the problem of handling constraints made by conjunctions of positive and negative literals based on the predicate symbols =, ∈,∪ and || (i.e., disjointness of two sets) in a (hybrid) universe of finite sets . We also review and compare the main techniques considered to represent finite sets in the context of logic languages. The resulting contraint algorithms are embedded in a Constraint Logic Programming (CLP) language which provides finite sets—along with basic set-theoretic operations—as first-class objects of the language. The language—called CLP( SET )—is an instance of the general CLP framework, and as such it inherits all the general features and theoretical results of this scheme. We provide, through programming examples, a taste of the expressive power offered by programming in CLP( SET ).

The first-order theories of lists, multisets, compact lists (i.e., lists where the number of contiguous occurrences of each element is immaterial), and sets are introduced via axioms. Such axiomatizations are shown to be very well-suited for the integration with free functor symbols governed by the classical Clark's axioms in the context of (Constraint) Logic Programming. Adaptations of the extensionality principle to the various theories taken into account is then exploited in the design of unification algorithms for the considered data structures. All the theories presented can be combined providing frameworks to deal with several of the proposed data structures simultaneously. The unification algorithms proposed can be combined (merged) as well, to produce engines for such combination theories.

The ability to deal with programs as data is a valuable feature of a programming language which can be advantageously exploited in a number of different applications, particularly in the artificial intelligence field and in the construction of programming environment tools. In this paper we describe the facilities for dealing with programs as data supplied by an extended Prolog, called EnvProlog. Such facilities are considered from a meta-programming viewpoint and are based on the capability of the language to designate (object level) programs via structural descriptive names (i.e. program names and program structures). A number of new built-in meta-predicates are supplied dealing with programs and meta-level representations of programs. Examples are given showing some interesting applications of these new facilities, in particular for program structuring and program composition. Finally, the implementation of the programs as data facility within the EnvProlog interpreter is briefly discussed.