What’s Decidable about Sequences?

We consider the first-order theory whose language has as nonlogical symbols the constant symbols 0 and 1, the binary relation symbols = and This theory of integers under addition is commonly called the 'Presburger Arithmetic' and is known to be decidable for truth [Presburger (1929), Hilbert and Bernays (1968)]. We prove here that there exists a decision procedure for this theory, involving quantifier elimination, for which there is a superexponential upper bound on the size of formula produced when all variables have been eliminated.

Lower bounds are established on the computational complexity of the decision problem and on the inherent lengths of proofs for two classical decidable theories of logic: the first-order theory of the real numbers under addition, and Presburger arithmetic — the first-order theory of addition on the natural numbers. There is a fixed constant c > 0 such that for every (nondeterministic) decision procedure for determining the truth of sentences of real addition and for all sufficiently large n, there is a sentence of length n for which the decision procedure runs for more than 2cn steps. In the case of Presburger arithmetic, the corresponding bound is \({2^{{2^{cn}}}}\). These bounds apply also to the minimal lengths of proofs for any complete axiomatization in which the axioms are easily recognized.KeywordsDecision ProcedureFinite Abelian GroupScanning HeadBinary WordReal AdditionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

We extend the terminological formalism of the well-known description logic ALC from concept inclusions (CIs) to more general constraints formulated in the quantifier-free fragment of Boolean Algebra with Presburger Arithmetic (QFBAPA). In QFBAPA one can formulate Boolean combinations of inclusion constraints and numerical constraints on the cardinalities of sets.Our new formalism extends, on the one hand, so-called cardinality restrictions on concepts, which have been introduced two decades ago, and on the other hand the recently introduced statistical knowledge bases. Though considerably more expressive, our formalism has the same complexity (NExpTime) as cardinality restrictions on concepts. We will also introduce a restricted version of our formalism for which the complexity is ExpTime. This yields the until now unknown exact complexity of the consistency problem for statistical knowledge bases.

This paper presents two decidability results on the validity checking problem for entailments of symbolic heaps in separation logic with Presburger arithmetic and arrays. The first result is for a system with arrays and existential quantifiers. The correctness of the decision procedure is proved under the condition that sizes of arrays in the succedent are not existentially quantified. This condition is different from that proposed by Brotherston et al. in 2017 and one of them does not imply the other. The main idea is a novel translation from an entailment of symbolic heaps into a formula in Presburger arithmetic. The second result is the decidability for a system with both arrays and lists. The key idea is to extend the unroll collapse technique proposed by Berdine et al. in 2005 to arrays and arithmetic as well as double-linked lists.Comment: arXiv admin note: text overlap with arXiv:1708.06696

This paper considers the satisfiability problem of symbolic heaps in separation logic with Presburger arithmetic and inductive definitions. First the system without any restrictions is proved to be undecidable. Secondly this paper proposes some syntactic restrictions for decidability. These restrictions are identified based on a new decidable subsystem of Presburger arithmetic with inductive definitions. In the subsystem of arithmetic, every inductively defined predicate represents an eventually periodic set and can be eliminated. The proposed system is quite general as it can handle the satisfiability of the arithmetical parts of fairly complex predicates such as sorted lists and AVL trees. Finally, we prove the decidability by presenting a decision procedure for symbolic heaps with the restricted inductive definitions and arithmetic.

Decision procedures can be either theory-specific, e.g., Presburger arithmetic, or theory-generic, applying to an infinite number of user-definable theories. Variant satisfiability is a theory-generic procedure for quantifier-free satisfiability in the initial algebra of an order-sorted equational theory \((\varSigma ,E \cup B)\) under two conditions: (i) \(E \cup B\) has the finite variant property and B has a finitary unification algorithm; and (ii) \((\varSigma ,E \cup B)\) protects a constructor subtheory \((\varOmega ,E_{\varOmega } \cup B_{\varOmega })\) that is OS-compact. These conditions apply to many user-definable theories, but have a main limitation: they apply well to data structures, but often do not hold for user-definable predicates on such data structures. We present a theory-generic satisfiability decision procedure, and a prototype implementation, extending variant-based satisfiability to initial algebras with user-definable predicates under fairly general conditions.

Inspired by Boyer and Moore''s approach for generating induction schemes based on terminating function definitions, Zhang, Kapur and Krishnamoorthy introduced a cover set method for designing induction schemes for automating proofs by induction from specifications expressed as equations and conditional equations. This method has been implemented in the theorem prover Rewrite Rule Laboratory (RRL) and a proof management system Tecton built on top of em RRL, and it has been used to prove many nontrivial theorems and reason about sequential as well as parallel programs. The cover set method is based on the assumption that a function symbol is defined using a finite set of terminating (conditional or unconditional) rewrite rules. The left side of the rules are then used to design different cases of an induction scheme, and recursive calls to the function made in the right side can be used to design appropriate instantiations for generating induction hypotheses. A weakness of this method is that it relies on syntactic unification for generating an induction scheme for a conjecture. This paper goes a step further by proposing semantic analysis for generating an induction scheme for a conjecture from a cover set. We discuss the use of a decision procedure for Presburger arithmetic (quantifier-free theory of numbers with the addition operation and relational predicates , , =, ) for performing semantic analysis about numbers. The decision procedure is used to generate appropriate induction schemes for a conjecture using cover sets of function taking numbers as arguments. This extension of the cover set method automates proofs of many theorems which otherwise, require human guidance and hints. The effectiveness of the method is demonstrated using some examples which commonly arise in reasoning about specifications and programs. It is also shown how semantic analysis using a Presburger arithmetic decision procedure can be used for checking the completeness of a cover set of a function defined using operations such as check, many function definitions used in a proof of the prime factorization theorem stating that every number can be factored uniquely into prime factors, which had to be checked manually, can now be checked automatically in procedure for guiding generalization for generating conjectures and merging induction schemes is also illustrated.

Motivated by applications to program verification, we study a decision procedure for satisfiability in an expressive fragment of a theory of arrays, which is parameterized by the theories of the array elements. The decision procedure reduces satisfiability of a formula of the fragment to satisfiability of an equisatisfiable quantifier-free formula in the combined theory of equality with uninterpreted functions (EUF), Presburger arithmetic, and the element theories. This fragment allows a constrained use of universal quantification, so that one quantifier alternation is allowed, with some syntactic restrictions. It allows expressing, for example, that an assertion holds for all elements in a given index range, that two arrays are equal in a given range, or that an array is sorted. We demonstrate its expressiveness through applications to verification of sorting algorithms and parameterized systems. We also prove that satisfiability is undecidable for several natural extensions to the fragment. Finally, we describe our implementation in the πVC verifying compiler.

Coq is a proof assistant featuring a tactic-based interactive theorem prover. The latest incarnation comes with over 150 tactics that assist the user in developing a formal proof. These tactics range from the simple and mundane to the ‘allpowerful’. Some examples from the latter category are the omega tactic that solves a goal in Presburger arithmetic and the ring and field tactics that solve identities modulo associativity and commutativity in ring and field structures. This paper presents a new proof tactic that decides equalities and inequalities between terms over lattices. It uses a decision procedure that is a variation on Whitman’s algorithm and is implemented using a technique known as proof by reflection. We will paint the essence of the approach in broad strokes and discuss the use of certified functional programs to aid the automation of formal reasoning. This paper makes three contributions. Firstly it serves an an introduction to using proof by reflection approach Coq. This utilizes the Ltac language and two recent extensions to the Coq system: type classes and the PROGRAM extension. Secondly it gives a certified implementation of Whitman’s algorithm in Coq, with proofs of correctness and termination. Thirdly, the final product of this work is a useable proof tactic that can be applied to proof goals involving equalities and inequalities in lattice theory. The rest of the paper is organized as follows: Section 2 will give a short introduction to Coq, highlighting the concept of a proof term, and will refresh the necessary details of lattice theory. We will give a motivation for the problem in Section 3, and a Coq-based introduction to free lattices along with the decision

In this paper we present stable and unstable versions of several well-known relations from mereotopology: part-of, overlap, underlap and contact. An intuitive semantics is given for the stable and unstable relations, describing them as dynamic counterparts of the base mereotopo-logical relations. Stable relations are described as ones that always hold, while unstable relations hold sometimes. A set of first-order sentences is provided to serve as axioms for the stable and unstable relations, and representation theory is developed in similar fashion to Stone’s representation theory for Boolean algebras and distributive lattices. Then we present some results about the first-order predicate logic of these relations and about its quantifier-free fragment. Completeness theorems for these logics are proved, the full first-order theory is proved to be hereditary undecidable and the satisfiability problem of the quantifier-free fragment is proved to be NP-complete.

Separation logic (SL) is a widely used formalism for verifying programs that manipulate dynamically allocated memory, relying on the separating conjunction $$\star $$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mo>⋆</mml:mo> </mml:math> to combine disjoint heap structures. The standard approach in SL lacks the expressive power to handle overlaid data structures where multiple structures share some locations. We consider a logic that extends SL with a new separating conjunction operator "Image missing", enabling the composition of heaps with shared locations that allocate distinct fields. Our fragment supports generic inductive definitions and introduces set variables to constrain the locations shared by overlapping structures. We prove that the satisfiability problem for this fragment is in Nexptime , by reducing it to the satisfiability problem in BAPA [11], a decidable logic combining Boolean algebra of sets and Presburger arithmetic.

Consider the first order theory of the real numbers with the function + (plus) and the predicate $ < $ (less than). Let S be the set of true sentences of this theory. We first present an elimination of quantifiers decision procedure for S, and then analyze it to show that it takes at most time $2^{2cn} $, where c is a constant, to decide sentences of length n. We next show that a given sentence does not change in truth value when each of the quantifiers is limited to range over an appropriately chosen finite set of rationals. This fact leads to a new decision procedure for S which uses at most space $2^{cn} $. We also remark that our methods lead to a decision procedure for Presburger arithmetic which operates within space $2^{2cn} $. These upper bounds should be compared with the results of Fischer and Rabin [2] that for some constant c, real addition requires time $2^{cn} $ and Presburger arithmetic requires time $2^{2cn} $.

A symbolic algorithm for the case-split rule in solving word constraints with extensions

Here we study the computational complexity of the constrained synchronization problem for the class of regular commutative constraint languages. Utilizing a vector representation of regular commutative constraint languages, we give a full classification of the computational complexity of the constraint synchronization problem. Depending on the constraint language, our problem becomes PSPACE-complete, NP-complete or polynomial time solvable. In addition, we derive a polynomial time decision procedure for the complexity of the constraint synchronization problem, given some constraint automaton accepting a commutative language as input.

A generalization of the problem of interactive configuration has previously been presented in [1]. This generalization utilized decomposition to extend the standard finite domain interactive configuration framework to deal with unbounded string variables and provided features such as prefix auto-completion. In this paper we present several significant improvements to the core data structures and algorithms in [1] as well as the first implementation of an interactive configurator on string variables. The primary improvement is obtained by replacing the binary decomposition model with a finite domain model. We then describe an optimization for this model which allows us to replace the use of costly conjunctions with simple restrict operations during synchronization between decomposed constraints. In addition we describe how to improve the performance of the auto-complete operation, by using projection on relevant variables to significantly reduce the size of the data structures involved. We empirically verify the critical significance of these improvements using our own implementation of a string variable based configurator on real-world example data.