TL;DR: This work uses inference rules to compute summaries of loop summaries and was able to verify safety properties for many examples which are out of the scope of several existing tools.
Abstract: A problem common to most of the tools based on the abstraction refinement paradigm is the divergence of the CEGAR process. In particular, infinitely many (spurious) counterexamples may arise from unfolding the same (while- or for-) loop in the given program again and again; this leads to an infinite or at least too large sequence of refinement steps. Loop summarization is an approach that permits to overcome this problem. It consists of abstracting not just states but also the state changes (transition relation) induced by structured program statements. The effectiveness of this approach depends on two factors: (a) the computation of loop summaries must not be the bottleneck of the verification algorithm (b) loop summaries must be precise enough to prove the property of interest. We present a technique that permits to achieve both goals. It uses inference rules to compute summaries. A lightweight test is performed to check whether a given loop matches the premise of a given rule. If so, a summary is automatically inferred by instantiating the rule. Despite its simplicity, our technique performs well in practice. We were able to verify safety properties for many examples which are out of the scope of several existing tools.
TL;DR: This work presents the first method to automatically prove fair termination of depth-bounded systems by systematically augmenting an over-approximation of the system's reachable states with a finite set of counters.
Abstract: Depth-Bounded Systems form an expressive class of well-structured transition systems They can model a wide range of concurrent infinite-state systems including those with dynamic thread creation, dynamically changing communication topology, and complex shared heap structures We present the first method to automatically prove fair termination of depth-bounded systems Our method uses a numerical abstraction of the system, which we obtain by systematically augmenting an over-approximation of the system's reachable states with a finite set of counters This numerical abstraction can be analyzed with existing termination provers What makes our approach unique is the way in which it exploits the well-structuredness of the analyzed system We have implemented our work in a prototype tool and used it to automatically prove liveness properties of complex concurrent systems, including nonblocking algorithms such as Treiber's stack and several distributed processes Many of these examples are beyond the scope of termination analyses that are based on traditional counter abstractions
TL;DR: This paper describes and compares three models of the transition constraint that is used to model a state change in resources in the scheduling engine of Visopt ShopFloor system.
Abstract: Constraint-based scheduling is an approach for solving scheduling problems using constraint satisfaction techniques. Its main advantage over the traditional scheduling techniques is possibility to model real-life restrictions via specialised constraints. In the paper we propose a concept of the transition constraint that is used to model a state change in resources. We describe and compare three models of the transition constraint. These models have been implemented and tested in the scheduling engine of Visopt ShopFloor system.
TL;DR: This report contains the results of the first investigations on the OODM, where it is shown that integrity enforcement is always possible and that object-oriented datamodels i, classes are value-representable.
Abstract: It is claimed that object oriented databases (OODBs) overcome many of the limitations of the relational model. However, the formal foundation of OODB concepts is still an open problem. Even worse, for relational databases a commonly accepted datamodel existed very early on whereas for OODBs the uni,cation of concepts is outstanding. Our research in Hamburg and Rostock is directed towards a formally founded object oriented datamodel (OODM) and to contribute to the development of a uniform mathematical theory of OODBs. This report contains the results of our first investigations on the OODM. A clear distinction between objects and values turns out to be essential in the OODM. Types and Classes are used to structure values and objects repectively. Then the problem of unique object identi,cation occurs. We show that this problem can be be solved for classes with extents that are completely representable by values. Such classes are called valuerepresentable. The finiteness of a database and the existence of finitely representable rational tree types are sufficient to decide value-representability. Another advantage of the relational approach is the existence of structurally determined canonical update operations. We show that this property can be carried over to object-oriented datamodels i, classes are value-representable. Moreover, in this case database consistency with respect to implicitly specified referential and inclusion constraints will be automatically preserved. This result can be generalized with respect to distinguished classes of explicitly stated static constraints. We show that integrity enforcement is always possible. Given some arbitrary method S and some static or transition constraint I there exists a greatest consistent specialization (GCS) SI of S with respect to I. Such a GCS behaves nice in that it is compatible with the conjunction of constraints, inheritance and refinement. For the GCS construction of a user-defined operation, however, it is in general not suffcient to replace the involved primitive update operations by their GCSs. From an engineering point of view an algorithm is required to generate these consistent operations. We address this construction problem by the specification of generators for them. These generators will be based on the possibility to represent syntactic components of the language as values within the language itself, which is known to form the basis of linguistic reflection. Moreover, the generators involve a single generic proof of correctness hence relieve the user of the burden to write basic update operations and to assure their consistency.
TL;DR: The algorithm is targeted at single transition constraint, which is affected by single node updating, and shows the algorithm performs in cubic growth while still in polynomial efficiency.
Abstract: In this paper, we propose a checking algorithm for dynamic constraint validation during XML updates. Our algorithm is targeted at single transition constraint, which is affected by single node updating. To the best of our knowledge, almost all constraints that have been preserved in the previous XML updates works are for static constraints. On the other hand, dynamic constraints restrict the transition of data from a current state into a new state. The operations that can affect these constraints involve node replacement, value of element and attribute replacement, and insert-delete pairing operations of nodes and their values. We propose a lightweight XML file to store only required data for the validation, i.e. states that need to be changed are extracted from XQuery and original XML documents. For experimentation purposes, we apply the algorithm in Java platform with the support of Schematron for the dynamic constraint and BaseX for parsing XQuery statements. The analysis shows our algorithm performs in cubic growth while still in polynomial efficiency. Nevertheless, our proposed dynamic constraint file is not minimal enough if the query involves indirect states transitions caused by sub queries. We would like to continue and extend the work with more types of dynamic constraint.