Two approaches for proving linearizability of multiset

A method is presented for using symbolic execution to generate the verification conditions required for proving correctness of programs written in a tasking subset of Ada. The symbolic execution rules are derived from proof systems that allow tasks to be verified independently in local proofs, which are then checked for cooperation. The isolation nature of this approach to symbolic execution of concurrent programs makes it better suited to formal verification than the more traditional interleaving approach, which suffers from combinatorial problems. The criteria for correct operation of a concurrent program include partial correctness, as well as more general safety properties, such as mutual exclusion and freedom from deadlock.

Automated Theorem Proving systems are enormously powerful computer programs capable of solving immensely difficult problems. The extreme capabilities of these systems lie on some well-established proof systems. Semantic tableau is such a proof system used to prove the validity of a formula by contradiction and can produce a counterexample if it fails. It can also be used to prove whether a formula is a logical consequence of a set of formulas. Tableau can be used in propositional logic, predicate logic, modal logic, temporal logic, and in other non-classical logics. In this paper, we describe the implementation of a sequential tableau algorithm for propositional logic using a procedural programming language rather then logic programming language. We also propose a tableau based proof system in a distributed environment using the message passing interface. Successful implementation of the proposed high performance approach will un-wrap an efficient paradigm for automated theorem proving.

This paper presents a logic that extends basicITL with explicit, interleaved programs. The calculus is based on symbolic execution, as previously described. We extend this former work here, by integrating the logic with higher-order logic, adding recursive procedures and rules to reason about fairness. Further, we show how rules for rely-guarantee reasoning can be derived and outline the application of some features to verify concurrent programs in practice. The logic is implemented in the interactive verification environment KIV.

We study the decidability of general verification problems for ASMs. This corresponds to the question whether all computations of an ASM satisfy a property (usually expressed in some temporal logic). Because of undecidability in the general case, one has to identify classes of ASMs and classes of properties in order to receive positive decidability results. One idea for this could be to put simple restrictions on the ASMs as forbidding certain advanced constructs. But it turns out that this does not help much. Additionally, the restrictions in those cases are very strong. Consequently, one has to look for others. Such restrictions may result from techniques which are intended to be used in the proofs of decidability. One proof technique is the reduction to a decidable reasoning problem in logic. In [8] and [10], this has been applied to receive some positive decidability results. In this paper, we identify further classes of ASMs and classes of properties for which the general verification problem is decidable. Each proof is a reduction to the satisfiability problem of a fragment of linear temporal first-order logic which has respectively been proved to be decidable in [6] or [7].

Temporal Connectives versus Explicit Timestamps to Query Temporal Databases

Open reactive systems are systems that ideally never terminate and are intended to maintain some interaction with their environment. Temporal logic is one of the methods for formal specification description of open reactive systems. For an open reactive system specification, we do not always obtain a program satisfying it because the open reactive system program must satisfy the specification no matter how the environment of the open reactive system behaves. This problem is known as realizability and the complexity of realizability check is double or triple exponential time of the length of specification formula and realizability checking of specifications is impractical. This paper implements stepwise satisfiability checking procedure with tableau method and proof system. Stepwise satisfiability is one of the necessary conditions of realizability of reactive system specifications. The implemented procedure uses proof system that is introduced in this paper. This proof system can accelerate the decision procedure, but since it is imcomplete it cannot itself decide the realizability property of specifications. The experiment of this paper shows that the implemented procedure can decide the realizability property of several specifications.

This paper presents an interactive proof method for the verification of temporal properties of concurrent systems based on symbolic execution. Symbolic execution is a well known and very intuitive strategy for the verification of sequential programs. We have carried over this approach to the interactive verification of arbitrary linear temporal logic properties of (infinite state) parallel programs. The resulting proof method is very intuitive to apply and can be automated to a large extent. It smoothly combines first-order reasoning with reasoning in temporal logic. The proof method has been implemented in the interactive verification environment KIV and has been used in several case studies.

This dissertation presents a resolution proof technique for Propositional Linear Temporal Logic of discrete time with the "Until" operator. The presented proof technique stems from the resolution method developed by L. Farinas del Cerro and A. Cavalli. However, their method is incomplete, and their completeness proof, as originally reported, is incorrect. Unlike Farinas's method, our proof technique incorporated the "Until" operator, which is a very powerful and useful in describing complex temporal relationships which are common in many areas of computer science. Our technique is also proved complete. The presented resolution method for linear temporal logic is similar to classical resolutions: the main goal is to show unsatisfiability of a set of temporal clauses by locating, either directly or indirectly, a state which contains unsatisfiability. Subsequent resolvents of a refutation are obtained by resolving out complementary literals referring to the same instant of time. In order to increase the efficiency of the resolution proof technique, we have developed a refinement of the presented basic method. This refinement is similar to the well-known Ordered Linear (OL) strategy for classical resolution. We also present the lifting of the basic resolution method to predicate linear temporal logic. Unlike First Order Logic, clauses of predicate linear temporal logic may contain variables which are quantified existentially, because skolemization is not valid here. We use standard unification with substitution on universally quantified variables. However, if a term substituted in place of a variable contains any flexible symbols, a constant or a function is flexible if it has different translation in different states, then all occurrences of the substituted variable must refer to the same instant of time (state). Otherwise, the unification may lead to incorrect results. Resolution in predicate linear temporal logic, though very useful from a practical standpoint, is incomplete, since no predicate temporal logic with arithmetic model of time is complete.

A sound and complete proof system for a unified temporal logic

Theorem proving is a widely used approach to the verification of computer systems, and its theoretical basis is generally a proof system for formal derivation of logic formulas. In this paper, we propose a proof system for Propositional Projection Temporal Logic (PPTL) with indexed expressions, which is a unified temporal logic that subsumes the well-used Linear Temporal Logic (LTL). First, the syntax, semantics and logic laws of PPTL that allows indexed expressions are introduced, and the representation of LTL constructs by PPTL formulas is shown. Then, the proof system for the logic is presented which consists of axioms and inference rules for the derivation of both basic constructs and indexed expressions of PPTL. To show the capability of the proof system, several examples of formal proofs are provided. Finally, the soundness of the proof system is demonstrated.

Linear-time temporal logic is applied to the verification of control systems. A formal language and proof system are adapted from those used in the verification of concurrent programs by Manna and Pnueli. Properties of some simple control systems are then verified by formally deducing temporal logic specifications of desired behaviour from descriptions of system dynamics. Finally, the usefulness of temporal logic in control theory is discussed and topics for future research are suggested.

The behavior model of traditional temporal logic is closed and symmetrical, while the behavior model of aspect-oriented programs is open and asymmetrical. When the programmer designs the base-code, he is not sure what aspects will be woven to it. It is indirect and difficult to specify and verify the behavior of aspect-oriented programs by using traditional temporal logic. In this paper, we propose a new temporal logic named open temporal logic, which introduced some new path operators and one new temporal operator. Since paths are divided into two kinds: internal parts and external parts, the behavioral model of open temporal logic is open and asymmetrical. Base on open temporal logic and the proof system of traditional rely-guarantee method, a new proof system is given to verify the behavior of aspect-oriented programs.

In this paper, we consider branching time temporal logic CT L with epistemic modalities for knowledge (belief) and with awareness operators. These logics involve the discrete-time linear temporal logic operators “next” and “until” with the branching temporal logic operator “on all paths”. In addition, the temporal logic of knowledge (belief) contains an indexed set of unary modal operators “agent i knows” (“agent i believes”). In a language of these logics, there are awareness operators. For these logics, we present sequent calculi with a restricted cut rule. Thus, we get proof systems where proof-search becomes decidable. The soundness and completeness for these calculi are proved.

Verification of concurrent programs still poses one of the major challenges in computer science. Several techniques to tackle this problem have been proposed. However, they often do not scale. We present an adaptation of the rely/guarantee methodology in dynamic logic. Rely/guarantee uses functional specification to symbolically describe the behavior of concurrently running threads: while each thread guarantees adherence to a specified property at any point in time, all other threads can rely on this property being established. This allows to regard threads largely in isolation--only w.r.t. an environment constrained by these specifications. While rely/guarantee based approaches often suffer from a considerable specification overhead, we complement functional thread specifications with frame conditions. We will explain our approach using a simple, but concurrent programing language. Besides the usual constructs for sequential programs, it caters for dynamic thread creation. We define semantics of concurrent programs w.r.t. an underspecified deterministic scheduling function. To formally reason about programs of this language, we introduce a novel multi-modal logic, Concurrent Dynamic Trace Logic (CDTL). It combines the strengthes of dynamic logic with those of linear temporal logic and allows to express temporal properties about symbolic program traces. We first develop a sound and complete sequent calculus for the logic subset that uses the sequential part of the language, based on symbolic execution. In a second step, we extend this to a calculus for the complete logic by adding symbolic execution rules for concurrent interleavings and dynamic thread creation based on the rely/guarantee methodology. Again, this calculus is proven sound and complete.

We show how to construct proof systems for NP languages where a deterministic polynomial-time verifier can check membership, given any N/sup (2/3)+/spl epsi// bits of an N-bit witness of membership. We also provide a slightly superpolynomial time proof system where the verifier can check membership, given only N/sup (1/2)+/spl epsi// bits of an N-bit witness. These pursuits are motivated by the work of Gal et. al. (1997). In addition, we construct proof systems where a deterministic polynomial-time verifier can check membership, given an N-bit string that agrees with a legitimate witness on just (N/2)+N/sup (4/5)+/spl epsi// bits. Our results and framework have applications for two related areas of research in complexity theory: proof systems for NP, and the relative power of Cook reductions and Karp-Levin type reductions. Our proof techniques are based on algebraic coding theory and small sample space constructions.