A Landscape of First-Order Linear Temporal Logics in Infinite-State Verification and Temporal Ontologies

We provide an overview of the main attempts to formalize and reason about the evolution over time of complex domains, through the lens of first-order temporal logics. Different communities have studied similar problems for decades, and some unification of concepts, problems and formalisms is a much needed but not simple task

Propagators and Solvers for the Algebra of Modular Systems

To appear in the proceedings of LPAR 21. Solving complex problems can involve non-trivial combinations of distinct knowledge bases and problem solvers. The Algebra of Modular Systems is a knowledge representation framework that provides a method for formally specifying such systems in purely semantic terms. Formally, an expression of the algebra defines a class of structures. Many expressive formalism used in practice solve the model expansion task, where a structure is given on the input and an expansion of this structure in the defined class of structures is searched (this practice overcomes the common undecidability problem for expressive logics). In this paper, we construct a solver for the model expansion task for a complex modular systems from an expression in the algebra and black-box propagators or solvers for the primitive modules. To this end, we define a general notion of propagators equipped with an explanation mechanism, an extension of the alge- bra to propagators, and a lazy conflict-driven learning algorithm. The result is a framework for seamlessly combining solving technology from different domains to produce a solver for a combined system.Comment: To appear in the proceedings of LPAR 2

An Improved Tight Closure Algorithm for Integer Octagonal Constraints

Integer octagonal constraints (a.k.a. ``Unit Two Variables Per Inequality'' or ``UTVPI integer constraints'') constitute an interesting class of constraints for the representation and solution of integer problems in the fields of constraint programming and formal analysis and verification of software and hardware systems, since they couple algorithms having polynomial complexity with a relatively good expressive power. The main algorithms required for the manipulation of such constraints are the satisfiability check and the computation of the inferential closure of a set of constraints. The latter is called `tight' closure to mark the difference with the (incomplete) closure algorithm that does not exploit the integrality of the variables. In this paper we present and fully justify an O(n^3) algorithm to compute the tight closure of a set of UTVPI integer constraints.Comment: 15 pages, 2 figure

Application of rewriting techniques to verification problems

The goal of the project is to employ techniques from term rewriting to verification problems. The relationship between liveness properties and termination of term rewrite systems (TRSs) is of particular interest. The emphasis is on the investigation of such properties for infinite state space systems where standard model checking techniques fail. Next to developing the necessary underlying theory and performing a case study analysis, the possibility to automate this approach is of great importance. In this paper we discuss the motivation of such work, present the results obtained so far, discuss related work and present plans for the further research

Decidability of the Monadic Shallow Linear First-Order Fragment with Straight Dismatching Constraints

The monadic shallow linear Horn fragment is well-known to be decidable and has many application, e.g., in security protocol analysis, tree automata, or abstraction refinement. It was a long standing open problem how to extend the fragment to the non-Horn case, preserving decidability, that would, e.g., enable to express non-determinism in protocols. We prove decidability of the non-Horn monadic shallow linear fragment via ordered resolution further extended with dismatching constraints and discuss some applications of the new decidable fragment.Comment: 29 pages, long version of CADE-26 pape

Analysing Parallel Complexity of Term Rewriting

We revisit parallel-innermost term rewriting as a model of parallel computation on inductive data structures and provide a corresponding notion of runtime complexity parametric in the size of the start term. We propose automatic techniques to derive both upper and lower bounds on parallel complexity of rewriting that enable a direct reuse of existing techniques for sequential complexity. The applicability and the precision of the method are demonstrated by the relatively light effort in extending the program analysis tool AProVE and by experiments on numerous benchmarks from the literature.Comment: Extended authors' accepted manuscript for a paper accepted for publication in the Proceedings of the 32nd International Symposium on Logic-based Program Synthesis and Transformation (LOPSTR 2022). 27 page

Complete First-Order Axiomatization of Finite or Infinite M-extended Trees

We present in this paper an axiomatization of the structure of finite or infinite $M$-extended trees. Having a structure $M=(D_M,F_M,R_M)$, we define the structure of finite or infinite $M$-extended trees $Ext_M=(D,F,R)$ whose domain $D$ consists of trees labelled by elements of $D_M\cup F$, where $F$ is a set of function symbols containing $F_M$ and another infinite set of function symbols disjoint from $F_M$. For each $n$-ary function symbol $f\in F$, the operation $f(a_1,..,a_n)$ is evaluated in $M$ and produces an element of $D_M$ if $f\in F_M$ and all the $a_i$ are elements of $D_M$, or is a tree whose root is labelled by $f$ and whose immediate children are $a_1,..,a_n$ otherwise. The set of relations $R$ contains $R_M$ and another relation which distinguishes the elements of $D_M$ from the others. Using a first-order axiomatization $T$ of $M$, we give a first-order axiomatization $\cal{T}$ of the structure $Ext_M$ and show that if $T$ is {\em flexible} then $\cal{T}$ is {\em complete}. The flexible theories are particular theories whose function and relation symbols have some elegant properties which enable us to handle formulae more easily

On Complexity Bounds and Confluence of Parallel Term Rewriting

We revisit parallel-innermost term rewriting as a model of parallel computation on inductive data structures and provide a corresponding notion of runtime complexity parametric in the size of the start term. We propose automatic techniques to derive both upper and lower bounds on parallel complexity of rewriting that enable a direct reuse of existing techniques for sequential complexity. Our approach to find lower bounds requires confluence of the parallel-innermost rewrite relation, thus we also provide effective sufficient criteria for proving confluence. The applicability and the precision of the method are demonstrated by the relatively light effort in extending the program analysis tool AProVE and by experiments on numerous benchmarks from the literature.Comment: Under submission to Fundamenta Informaticae. arXiv admin note: substantial text overlap with arXiv:2208.0100