共查询到20条相似文献,搜索用时 31 毫秒
1.
Nikolaj S. Bjørner Anca Browne Michael A. Colón Bernd Finkbeiner Zohar Manna Henny B. Sipma Tomás E. Uribe 《Formal Methods in System Design》2000,16(3):227-270
We review a number of formal verification techniques supported by STeP, the Stanford Temporal Prover, describing how the tool can be used to verify properties of several versions of the Bakery Mutual exclusion algorithm for mutual exclusion. We verify the classic two-process algorithm and simple variants, as well as an atomic parameterized version. The methods used include deductive verification rules, verification diagrams, automatic invariant generation, and finite-state model checking and abstraction. 相似文献
2.
K. Baukus K. Stahl S. Bensalem Y. Lakhnech 《Electronic Notes in Theoretical Computer Science》2001,50(4):386-400
In general, the verification of parameterized networks is undecidable. In recent years there has been a lot of research to identify subclasses of parameterized systems for which certain properties are decidable. Some of the results are based on finite abstractions of the parameterized system in order to use model-checking techniques to establish those properties. In a previous paper we presented a method which allows to compute abstractions of a parameterized system modeled in the decidable logic WS1S. These WS1S systems provide an intuitive way to describe parameterized systems of finite state processes. In practice however, the processes in the network themselves are infinite because of unbounded data structures. One source of unboundedness can be the usage of a parameterized data structure. Another typical source may be the presence of structures ranging over subsets of participating processes. E.g., this is the case for group membership or distributed shared memory consistency protocols. In this paper we use deductive methods to deal with such networks where the data structure is parameterized by the number of processes and an extra parameter. We show how to derive an abstract WS1S system which can be subject to algorithmic verification. For illustration of the method we verify the correctness of a distributed shared memory consistency protocol using PVS for the deductive verification part and the tools PAX and SMV for the algorithmic part. 相似文献
3.
Takahiro Seino Kazuhiro Ogata Kokichi Futatsugi 《Electronic Notes in Theoretical Computer Science》2006,147(1):57
The OTS/CafeOBJ method can be used to model, specify and verify distributed systems. Specifications are written in equations, which are regarded as rewrite rules and used to verify specifications. The usefulness of the method is demonstrated by applying the method to nontrivial problems such as electronic commerce protocols and railroad signaling systems. In this paper we describe a toolkit called Buffet, which assists verification in the method. Given predicates used to split cases and lemmas, Buffet automatically generates proofs (called proof scores) and checks the proof scores using the CafeOBJ system. Buffet also has facilities to display proof scores generated and verification results on a web browser. 相似文献
4.
Sabine Glesner Johannes Leitner Jan Olaf Blech 《Electronic Notes in Theoretical Computer Science》2007,176(3):61
Formal verification methods have gained increased importance due to their ability to guarantee system correctness and improve reliability. Nevertheless, the question how proofs are to be formalized in theorem provers is far from being trivial, yet very important as one needs to spend much more time on verification if the formalization was not cleverly chosen. In this paper, we develop and compare two different possibilities to express coinductive proofs in the theorem prover Isabelle/HOL. Coinduction is a proof method that allows for the verification of properties of also non-terminating state-transition systems. Since coinduction is not as widely used as other proof techniques as e.g. induction, there are much fewer “recipes” available how to formalize corresponding proofs and there are also fewer proof strategies implemented in theorem provers for coinduction. In this paper, we investigate formalizations for coinductive proofs of properties on state transition sequences. In particular, we compare two different possibilities for their formalization and show their equivalence. The first of these two formalizations captures the mathematical intuition, while the second can be used more easily in a theorem prover. We have formally verified the equivalence of these criteria in Isabelle/HOL, thus establishing a coalgebraic verification framework. To demonstrate that our verification framework is suitable for the verification of compiler optimizations, we have introduced three different, rather simple transformations that capture typical problems in the verification of optimizing compilers, even for non-terminating source programs. 相似文献
5.
Alternating systems are models of computer programs whose behavior is governed by the actions of multiple agents with, potentially, different goals. Examples include control systems, resource schedulers, security protocols, auctions and election mechanisms. Proving properties about such systems has emerged as an important new area of study in formal verification, with the development of logical frameworks such as the alternating temporal logic ATL*. Techniques for model checking ATL* over finite-state systems have been well studied, but many important systems are infinite-state and thus their verification requires, either explicitly or implicitly, some form of deductive reasoning. This paper presents a theoretical framework for the analysis of alternating infinite-state systems. It describes models of computation, of various degrees of generality, and alternating-time logics such as ATL* and its variations. It then develops a proof system that allows to prove arbitrary ATL* properties over these infinite-state models. The proof system is shown to be complete relative to validities in the weakest possible assertion language. The paper then derives auxiliary proof rules and verification diagrams techniques and applies them to security protocols, deriving a new formal proof of fairness of a multi-party contract signing protocol where the model of the protocol and of the properties contains both game-theoretic and infinite-state (parameterized) aspects. 相似文献
6.
The real-time process calculus Timed CSP is capable of expressing properties such as deadlock-freedom and real-time constraints.
It is therefore well-suited to model and verify embedded software. However, proofs about Timed CSP specifications are not
ensured to be correct since comprehensive machine-assistance for Timed CSP is not yet available. In this paper, we present
our formalization of Timed CSP in the Isabelle/HOL theorem prover, which we have formulated as an operational coalgebraic
semantics together with bisimulation equivalences and coalgebraic invariants. This allows for semi-automated and mechanically
checked proofs about Timed CSP specifications. Mechanically checked proofs enhance confidence in verification because corner
cases cannot be overlooked. We additionally apply our formalization to an abstract specification with real-time constraints.
This is the basis for our current work, in which we verify a simple real-time operating system deployed on a satellite. As
this operating system has to cope with arbitrarily many threads, we use verification techniques from the area of parameterized
systems for which we outline their formalization. 相似文献
7.
In this paper techniques are developed and compared that increase the inferential power of tableau systems for classical first-order logic. The mechanisms are formulated in the framework of connection tableaux, which is an amalgamation of the connection method and the tableau calculus, and a generalization of model elimination. Since connection tableau calculi are among the weakest proof systems with respect to proof compactness, and the (backward) cut rule is not suitable for the first-order case, we study alternative methods for shortening proofs. The techniques we investigate are the folding-up and the folding-down operations. Folding up represents an efficient way of supporting the basic calculus, which is top-down oriented, with lemmata derived in a bottom-up manner. It is shown that both techniques can also be viewed as controlled integrations of the cut rule. To remedy the additional redundancy imported into tableau proof procedures by the new inference rules, we develop and apply an extension of the regularity condition on tableaux and the mechanism of anti-lemmata which realizes a subsumption concept on tableaux. Using the framework of the theorem prover SETHEO, we have implemented three new proof procedures that overcome the deductive weakness of cut-free tableau systems. Experimental results demonstrate the superiority of the systems with folding up over the cut-free variant and the one with folding down.Work supported by the Deutsche Forschungsgemeinschaft and the Esprit Basic Research Action 6471 Medlar II. 相似文献
8.
The design and verification of fault-tolerant distributed algorithms is a complicated task. Usually, the proof of correctness is done manually, and thus depends on the skill of the prover. Using automated verification methods, such as model checking, can greatly simplify the verification. However, model checking of distributed algorithms is often intractable because of the state-explosion problem. In this paper we present a novel approach to verification of quorum-based distributed register emulation algorithms with undetectable crash failures of processes. Our approach is based on projection and abstraction and allows us to reduce the task of model-checking the whole system to fair model-checking of subsystems consisting of a constant number of processes. Our method is highly scalable and can be applied to a large class of algorithms. Aside from efficient verification, it can also be used for finding redundancies in existing algorithms. 相似文献
9.
This paper explores locality in proofs of global safety properties of concurrent programs. Model checking on the full state
space is often infeasible due to state explosion. A local proof, in contrast, is a collection of per-process invariants, which
together imply the desired global safety property. Local proofs can be more compact than global proofs, but local reasoning
is also inherently incomplete. In this paper, we present an algorithm for safety verification that combines local reasoning
with gradual refinement. The algorithm gradually exposes facts about the internal state of components, until either a local
proof or a real error is discovered. The refinement mechanism ensures completeness. Experiments show that local reasoning
can have significantly better performance over the traditional reachability computation. Moreover, for some parameterized
protocols, a local proof can be used as the basis of a correctness proof over all instances. 相似文献
10.
Many safety-critical systems that have been considered by the verification community are parameterized by the number of concurrent components in the system, and hence describe an infinite family of systems. Traditional model checking techniques can only be used to verify specific instances of this family. In this paper, we present a technique based on compositional model checking and program analysis for automatic verification of infinite families of systems. The technique views a parameterized system as an expression in a process algebra (CCS) and interprets this expression over a domain of formulas (modal mu-calculus), considering a process as a property transformer. The transformers are constructed using partial model checking techniques. At its core, our technique solves the verification problem by finding the limit of a chain of formulas. We present a widening operation to find such a limit for properties expressible in a subset of modal mu-calculus. We describe the verification of a number of parameterized systems using our technique to demonstrate its utility. 相似文献
11.
Ben L. Di Vito 《International Journal on Software Tools for Technology Transfer (STTT)》2000,3(1):20-31
We describe an approach and experimental results in the application of mechanized theorem proving to software requirements
analysis. Serving as the test article was the embedded controller for SAFER, a backpack propulsion system used as a rescue
device by NASA astronauts. SAFER requirements were previously formalized using the prototype verification system (PVS) during
a NASA pilot project in formal methods, details of which appear in a NASA guidebook. This paper focuses on the formulation
and proof of properties for the SAFER requirements model. To test the prospects for deductive requirements analysis, we used
the PVS theorem prover to explore the upper limits of proof automation. A set of property classes was identified, with matching
proof schemes later devised. After developing several PVS proof strategies (essentially prover macros), we obtained fully
automatic proofs of 42 model properties. These results demonstrate how customized prover strategies can be used to automate
moderate-complexity theorem proving for state machine models. 相似文献
12.
Yi Fang Nir Piterman Amir Pnueli Lenore Zuck 《International Journal on Software Tools for Technology Transfer (STTT)》2006,8(3):261-279
The method of invisible invariants was developed originally in order to verify safety properties of parameterized systems
in a fully automatic manner. The method is based on (1) a project&generalize heuristic to generate auxiliary constructs for parameterized systems and (2) a small-model theorem, implying that it is sufficient to check the validity of logical assertions of a certain syntactic form on small instantiations
of a parameterized system. The approach can be generalized to any deductive proof rule that (1) requires auxiliary constructs
that can be generated by project&generalize, and (2) the premises resulting when using the constructs are of the form covered by the small-model theorem.
The method of invisible ranking, presented here, generalizes the approach to liveness properties of parameterized systems. Starting with a proof rule and
cases where the method can be applied almost “as is,” the paper progresses to develop deductive proof rules for liveness and
extend the small-model theorem to cover many intricate families of parameterized systems. 相似文献
13.
Suman Roy Janardan Misra Indranil Saha 《Software Testing, Verification and Reliability》2016,26(8):548-571
We revisit the problem of real‐time verification with dense‐time dynamics using timeout and calendar‐based models and simplify this to a finite state verification problem. We introduce a specification formalism for these models and capture their behaviour in terms of semantics of timed transition systems. We discuss a technique, which reduces the problem of verification of qualitative temporal properties on infinite state space of a large fragment of these timeout and calender‐based transition systems into that on clock‐less finite state models through a two‐step process comprising of digitization and finitary reduction. This technique enables us to verify safety invariants for real‐time systems using finite state model checking avoiding the complexity of infinite state (bounded) model checking and scale up models without applying techniques from induction‐based proof methodology. In the same manner, we verify timeliness properties. Moreover, we can verify liveness for real‐time systems, which are not possible by using induction with infinite state model checkers. Copyright © 2016 John Wiley & Sons, Ltd. 相似文献
14.
We report on an experiment in combining the theorem prover Isabelle with automatic first-order arithmetic provers to increase
automation on the verification of distributed protocols. As a case study for the experiment we verify several averaging clock
synchronization algorithms. We present a formalization of Schneider’s generalized clock synchronization protocol [Sch87] in
Isabelle/HOL. Then, we verify that the convergence functions used in two clock synchronization algorithms, namely, the Interactive
Convergence Algorithm (ICA) of Lamport and Melliar-Smith [LMS85] and the Fault-tolerant Midpoint algorithm of Lundelius–Lynch
[LL84], satisfy Schneider’s general conditions for correctness. The proofs are completely formalized in Isabelle/HOL. We identify
parts of the proofs which are not fully automatically proven by Isabelle built-in tactics and show that these proofs can be
handled by automatic first-order provers with support for arithmetics. 相似文献
15.
The traditional studies of multi-prover interactive proof systems have concentrated on cooperating provers. These are systems in which a verifier interacts with a set of provers who collaborate in their attempt to convince
the verifier that a word is in a prespecified language L. Results on probabilistically checkable proofs coupled with parallel repetition techniques characterize NP in terms of multi-prover
proof systems: languages in NP can be verified through a one-round interaction with two cooperating provers using limited
randomness and communication.?Less attention has been paid to the study of competition in this complexity-theoretic setting of interactive proof systems. We consider, for example, one-round proof systems where
the first prover is trying to convince the verifier to accept and the second prover is trying to convince the verifier to
reject. We build into these proof systems a (crucial) asymmetry between the provers, analogous to quantifier alternation.
We show that such proof systems capture, with restrictions on communication and randomness, languages in NP. We generalize
this model by defining alternating prover proof systems which we show characterize each level of the polynomial hierarchy.
Alternating oracle proof systems are also examined.?The main contribution of this work is the first exact characterization
of the polynomial hierarchy in terms of interactive (prover) proof systems.
Received: November 19, 1997. 相似文献
16.
In this paper we discuss the problem of internalizing the meta-level transformations between (representations of) incomplete proofs and terms in a theorem prover based on Type Theory. These transformations (usually referred to as tactics) can be seen as meta-level functions between terms representing the state of the theorem prover. Starting with parameterized variables as representations of unknown terms, we propose an extension of the Pure Type Systems (PTSs) with parameterized abstractions. We show that such a system can adequately represent instances of tactics, i.e. the mapping between a state and the state resulting from it by the application of a given tactic.We establish the important meta-theoretical properties of the extended system such as confluence, subject reduction, normalization, etc. 相似文献
17.
This article discusses a new format of predicate diagrams for the verification of real-time systems. We consider systems that
are defined as extended timed graphs, a format that combines timed automata and constructs for modelling data, possibly over
infinite domains. Predicate diagrams are succinct and intuitive representations of Boolean abstractions. They also represent
an interface between deductive tools used to establish the correctness of an abstraction, and model checking tools that can
verify behavioral properties of finite-state models. The contribution of this article is to extend the format of predicate
diagrams to timed systems. We establish a set of verification conditions that are sufficient to prove that a given predicate
diagram is a correct abstraction of an extended timed graph; these verification conditions can often be discharged with SMT
solvers such as CVC-lite. Additionally, we describe how this approach extends naturally to the verification of parameterized
systems. The formalism is supported by a toolkit, and we demonstrate its use at the hand of Fischer’s real-time mutual-exclusion
protocol. 相似文献
18.
Deepak Kapur Mahadevan Subramaniam 《International Journal on Software Tools for Technology Transfer (STTT)》2000,3(1):32-65
We show that existing theorem proving technology can be used effectively for mechanically verifying a family of arithmetic
circuits. A theorem prover implementing: (i) a decision procedure for quantifier-free Presburger arithmetic with uninterpreted
function symbols; (ii) conditional rewriting; and (iii) heuristics for carefully selecting induction schemes from terminating
recursive function definitions; and (iv) well integrated with backtracking, can automatically verify number-theoretic properties
of parameterized and generic adders, multipliers and division circuits. This is illustrated using our theorem prover Rewrite Rule Laboratory (RRL). To our knowledge, this is the first such demonstration of the capabilities of a theorem prover mechanizing induction.
The above features of RRL are briefly discussed using illustrations from the verification of adder, multiplier and division
circuits. Extensions to the prover likely to make it even more effective for hardware verification are discussed. Furthermore,
it is believed that these results are scalable, and the proposed approach is likely to be effective for other arithmetic circuits
as well. 相似文献
19.
We propose a program verification method that combines random testing, model checking and interactive theorem proving. Testing and model checking are used for debugging programs and specifications before a costly interactive proof attempt. During proof development, testing and model checking quickly eliminate false conjectures and generate counterexamples which help to correct them. With an interactive theorem prover we also ensure the correctness of the reduction of a top level problem to subproblems that can be tested or proved. We demonstrate the method using our random testing tool and binary decision diagrams-based (BDDs) tautology checker, which are added to the Agda/Alfa interactive proof assistant for dependent type theory. In particular we apply our techniques to the verification of Haskell programs. The first example verifies the BDD checker itself by testing its components. The second uses the tautology checker to verify bitonic sort together with a proof that the reduction of the problem to the checked form is correct. 相似文献