T-resolution: refinements and model elimination

T-resolution is a binary rule, proposed by Policriti and Schwartz in 1995 for theorem proving in first-order theories (T-theorem proving) that can be seen - at least at the ground level - as a variant of Stickel's theory resolution. In this paper we consider refinements of this rule as well as the model elimination variant of it. After a general discussion concerning our viewpoint on theorem proving in first-order theories and a brief comparison with theory resolution, the power and generality of T-resolution are emphasized by introducing suitable linear and ordered refinements, uniformly and in strict analogy with the standard resolution approach. Then a model elimination variant of T-resolution is introduced and proved to be sound and complete; some experimental results are also reported. In the last part of the paper we present two applications of T-resolution: to constraint logic programming and to modal logic

Expressing Infinity without Foundation

The axiom of infinity can be expressed by stating the existence of sets satisfying a formula which involves restricted universal quantifiers only, even if the axiom of foundation is not assumed

Special Issue on Algorithms and Data-Structures for Compressed Computation

As the production of massive data has outpaced Moore’s law in many scientific areas, the very notion of algorithms is transforming [...

Modelling concurrent systems specified in a temporal concurrent constraint language -I

In this paper we present an approach to model concurrent systems specified in a temporal concurrent constraint language. Our goal is to construct a framework in which it is possible to apply the Model Checking technique to programs specified in such language. This work is the first step to the framework construction. We present a formalism to transform a specification into a tcc Structure. This structure is a graph representation of the program behavior. Our basic tool is the Timed Concurrent Constraint Programming (tcc) framework defined by Saraswat et al. to describe reactive systems. With this language we take advantage of both the natural properties of the declarative paradigm and of the fact that the notion of time is built into the semantics of the programming language. In fact, on this ground it becomes reasonable to introduce the idea of applying the technique of Model Checking to a finite time interval (introduced by the user). With this restriction we naturally force the space representing the behavior of the program to be finite and hence Model Checking algorithms to be applicable. The graph construction is a completely automatic process that takes as input the tcc specification

Modeling Concurrent systems specified in a Temporal Concurrent Constraint language-I

n/

The Automation of Syllogistic II. Optimization and Complexity Issues

In the first paper of this series it was shown that any unquantified formula p in the collection MLSSF (multilevel syllogistic extended with the singleton operator and the predicate Finite) can be decomposed as a disjunction of set-theoretic formulae called syllogistic schemes. The syllogistic schemes are satisfiable and no two of them have a model in common, therefore the previous result already implied the decidability of the class MLSSF by simply checking if the set of syllogistic schemes associated with the given formula is empty. In the first section of this paper a new and improved searching algorithm for syllogistic schemes is introduced, based on a proof of existence of a 'minimum effort' scheme for any given satisfiable formula in MLSF. The algorithm addressed above can be piloted quite effectively even though it involves backtracking. In the second part of the paper, complexity issues are studied by showing that the class of ( 00)o1-simple prenex formulae (an extension of MLS) has a decision problem which is NP-complete. The decision algorithm that proves the membership of this decision problem to NP can be seen as a different decision algorithm for ML

Decidability results for classes of purely universal formulae and quantifiers elimination in Set Theory

A general mechanism to extend decision algorithms to deal with additional predicates is described. The only conditions imposed on the predicates is stability with respect to some transitive relations

Continued Hereditarily Finite Set-Approximations

We study an encoding RA that assigns a real number to each hereditarily finite set, in a broad sense. In particular, we investigate whether the map RA can be used to produce codes that approximate any positive real number to arbitrary precision, in a way that is related to continued fractions. This is an interesting question because it connects the theory of hereditarily finite sets to the theory of real numbers and continued fractions, which have important applications in number theory, analysis, and other fields

A Linear-size Cascade Decomposition for Wheeler Automata

The Krohn-Rhodes Decomposition Theorem (KRDT) is a central result in automata and semigroup theories: it states that any (deterministic) finite-state automaton can be disassembled into a collection of automata of two simple types, that can be arranged into a combination - cascade - that simulates the original automaton. The elementary building blocks of the decomposition are either resets or permutations. The full-fledged theorem features two orthogonal dimensions of complexity: the type and the number of building blocks appearing in the cascade, and a deep step in the proof is the characterization of the permutations appearing in the decomposition. This characterization implies, in the case of counter-free automata, that the resulting cascade contains no permutations. In this paper we start analysing KRDT for two compression-oriented classes of automata: (i) path- coherent: state-ordered automata mapping state-intervals to state-intervals; (ii) Wheeler: a subclass of path-coherent automata whose order is the one induced by the co-lexicographic order of words. These classes were recently defined and studied and they turn out to be efficiently encodable and indexable. We prove that each automata in these classes can be decomposed as a cascade with a number of components which is linear in the number of states of the original automaton and, for the Wheeler class, we prove that only two-state resets are needed. Our line of reasoning avoids the necessity of using full KRDT and proves our results directly by a simple inductive argument