A decidable quantified fragment of set theory with ordered pairs and some undecidable extensions

In this paper we address the decision problem for a fragment of set theory with restricted quantification which extends the language studied in [4] with pair related quantifiers and constructs, in view of possible applications in the field of knowledge representation. We will also show that the decision problem for our language has a non-deterministic exponential time complexity. However, for the restricted case of formulae whose quantifier prefixes have length bounded by a constant, the decision problem becomes NP-complete. We also observe that in spite of such restriction, several useful set-theoretic constructs, mostly related to maps, are expressible. Finally, we present some undecidable extensions of our language, involving any of the operators domain, range, image, and map composition. [4] Michael Breban, Alfredo Ferro, Eugenio G. Omodeo and Jacob T. Schwartz (1981): Decision procedures for elementary sublanguages of set theory. II. Formulas involving restricted quantifiers, together with ordinal, integer, map, and domain notions. Communications on Pure and Applied Mathematics 34, pp. 177-195Comment: In Proceedings GandALF 2012, arXiv:1210.202

Extending iStar2.0 metamodel to define data structures

iStar2.0 provides a recommendation for the core constructs defined in the i* language, which are articulated around a metamodel. When applying iStar2.0 to a particular domain, it can be necessary to extend this metamodel in order to represent more specialized concepts. One of these domains is that of data structures, as implementation of abstract data types. In this paper, we build upon previous work on using i* to describe data structures from an intentional point of view, by introducing new constructs in iStar2.0 and adding them to the iStar2.0 metamodel. We illustrate the approach using some well-known abstract data types (sequences, functions, …) and the data structures implementing them (linked lists, heaps, hash tables, …).Peer ReviewedPostprint (published version

SMT Solving for Functional Programming over Infinite Structures

We develop a simple functional programming language aimed at manipulating infinite, but first-order definable structures, such as the countably infinite clique graph or the set of all intervals with rational endpoints. Internally, such sets are represented by logical formulas that define them, and an external satisfiability modulo theories (SMT) solver is regularly run by the interpreter to check their basic properties. The language is implemented as a Haskell module.Comment: In Proceedings MSFP 2016, arXiv:1604.0038

Investigating strategies for cooperative planning of independent agents through prototype evaluation

This paper discusses the application of the prototyping approach to investigating the requirements on strategies for cooperative planning and con ict resolution of independent agents by means of an example application: the strategic game \Scotland Yard". The strategies for coordinating the agents, which are parallel algorithms, are developed with a prototyping approach using ProSet-Linda. ProSet-Linda is designed for prototyping parallel algorithms. We concentrate on the techniques employed to elicit the requirements on the algorithms for agent interaction. The example application serves to illustrate the prototyping approach to requirements elicitation by means of a non-trivial instance for investigating algorithms for cooperative planning and con ict resolution

Investigating Strategies for Cooperative Planning of Independent Agents through Prototype Evaluation

This paper discusses the application of the prototyping approach to investigating the requirements on strategies for cooperative planning and conflict resolution of independent agents by means of an example application: the strategic game "Scotland Yard". The strategies for coordinating the agents, which are parallel algorithms, are developed with a prototyping approach using ProSet-Linda. ProSet-Linda is designed for prototyping parallel algorithms. We concentrate on the techniques employed to elicit the requirements on the algorithms for agent interaction. The example application serves to illustrate the prototyping approach to requirements elicitation by means of a non-trivial instance for investigating algorithms for cooperative planning and conflict resolution

Algorithm Choice For Multiple-Query Evaluation

Traditional query optimization concentrates on the optimization of the execution of each individual query. More recently, it has been observed that by considering a sequence of multiple queries some additional high-level optimizations can be performed. Once these optimizations have been performed, each operation is translated into executable code. The fundamental insight in this paper is that significant improvements can be gained by careful choice of the algorithm to be used for each operation. This choice is not merely based on efficiency of algorithms for individual operations, but rather on the efficiency of the algorithm choices for the entire multiple-query evaluation. An efficient procedure for automatically optimizing these algorithm choices is given

An Automatically Verified Prototype of the Tokeneer ID Station Specification

The Tokeneer project was an initiative set forth by the National Security Agency (NSA, USA) to be used as a demonstration that developing highly secure systems can be made by applying rigorous methods in a cost effective manner. Altran Praxis (UK) was selected by NSA to carry out the development of the Tokeneer ID Station. The company wrote a Z specification later implemented in the SPARK Ada programming language, which was verified using the SPARK Examiner toolset. In this paper, we show that the Z specification can be easily and naturally encoded in the {log} set constraint language, thus generating a functional prototype. Furthermore, we show that {log}'s automated proving capabilities can discharge all the proof obligations concerning state invariants as well as important security properties. As a consequence, the prototype can be regarded as correct with respect to the verified properties. This provides empirical evidence that Z users can use {log} to generate correct prototypes from their Z specifications. In turn, these prototypes enable or simplify some verificatio activities discussed in the paper

Investigating Parallel Interpretation-Tree Model Matching Algorithms with ProSet-Linda

This paper discusses the development of algorithms for parallel interpretation-tree model matching for 3-D computer vision applications such as object recognition. The algorithms are developed with a prototyping approach using ProSet-Linda. ProSet is a procedural prototyping language based on the theory of finite sets. The coordination language Linda provides a distributed shared memory model, called tuple space, together with some atomic operations on this shared data space. The combination of both languages, viz. ProSet -Linda, is designed for prototyping parallel algorithms. The classical control algorithm for symbolic data/model matching in computer vision is the Interpretation Tree search algorithm. This algorithm has a high computational complexity when applied to matching problems with large numbers of features. This paper examines parallel variations of this algorithm. Parallel execution can increase the execution performance of model matching, but also make feasible entirely new ways of solving matching problems. In the present paper, we emphasize the development of parallel algorithms with a prototyping approach, not the presentation of performance figures displaying increased performance through parallel execution. The expected improvements attained by the parallel algorithmic variations for interpretation-tree search are analyzed. The implementation of ProSet-Linda is briefly discussed

Investigating Strategies for Cooperative Planning of Independent Agents through Prototype Evaluation

This paper discusses the application of the prototyping approach to investigating the requirements on strategies for cooperative planning and conflict resolution of independent agents by means of an example application: the strategic game "Scotland Yard". The strategies for coordinating the agents, which are parallel algorithms, are developed with a prototyping approach using ProSet-Linda. ProSet-Linda designed for prototyping parallel algorithms. We concentrate o