Ranking Abstraction as Companion to Predicate Abstraction

@inproceedings{Balaban2005RankingAA,
  title={Ranking Abstraction as Companion to Predicate Abstraction},
  author={Ittai Balaban and Amir Pnueli and Lenore D. Zuck},
  booktitle={FORTE},
  year={2005}
}
Predicate abstraction has become one of the most successful methodologies for proving safety properties of programs. Recently, several abstraction methodologies have been proposed for proving liveness properties. This paper studies “ranking abstraction” where a program is augmented by a nonconstraining progress monitor, and further abstracted by predicate-abstraction, to allow for automatic verification of progress properties. Unlike most liveness methodologies, the augmentation does not… 

Modular Ranking Abstraction

TLDR
It is shown how the constructs necessary for a deductive proof of an arbitrary LTL formula can be automatically extracted from a successful application of the ranking abstraction method.

Ranking Abstractions

TLDR
An abstract interpretation algorithm for proving that a program terminates on all inputs that abstracts information that is usually not important for proving termination such as program invariants and yet it distinguishes between different reasons for termination which are not usually maintained in existing abstract domains.

Proving termination using abstract interpretation

TLDR
This thesis develops a series of abstract interpreters for proving the termination of imperative programs using metric spaces to model the semantics of infinite computations for programs with recursion over the unit type so that they can be designed in a systematic manner.

Infinite-State Liveness-to-Safety via Implicit Abstraction and Well-Founded Relations

TLDR
This work extends liveness-to-safety, a prominent approach in the finite-state case, by means of implicit abstraction, to effectively prove the absence of abstract fair loops without explicitly constructing the abstract state space.

Symbolic shape analysis

The goal of program verification is to ensure software reliability by establishing a mathematical proof which guarantees that the software behaves correctly. Program analysis tools assist the

Metric Spaces and Termination Analyses

TLDR
The power of the framework is illustrated by providing an instance that can automatically prove the termination of programs with general recursion, and a set of conditions for determining when an abstract interpreter is sound for analysing liveness properties are identified.

Proving Liveness Property under a Mixture of Strengthened Compassion and Compassion Requirements †

TLDR
It is shown how the constructs necessary for deductive proofs of liveness properties can be automatically extracted and an algorithm for automatically deriving deductive proof constructs is shown.

Syntax-Guided Termination Analysis

TLDR
New algorithms for proving program termination and non-termination using syntax-guided synthesis are presented, and the implementation, called FreqTerm, significantly outperforms state-of-the-art on proving non- termination of a class of programs arising from large-scale Event-Condition-Action systems.

Auxiliary Constructs for Proving Liveness in Compassion Discrete Systems

TLDR
This paper presents an approach which extends the work in [2] with compassion requirements, and is illustrated on two examples of sequential and concurrent programs.

References

SHOWING 1-10 OF 15 REFERENCES

Shape Analysis by Predicate Abstraction

The paper presents an approach for shape analysis based on predicate abstraction. Using a predicate base that involves reachability relations between program variables pointing into the heap, we are

Abstraction Refinement for Termination

TLDR
This paper presents the first known automatic counterexample-guided abstraction refinement algorithm for termination proofs and identifies two reasons for spuriousness: abstractions that are too coarse, and candidate transition invariants that aretoo strong.

Relative Completeness of Abstraction Refinement for Software Model Checking

Automated methods for an undecidable class of verification problems cannot be complete (terminate for every correct program). We therefore consider a new kind of quality measure for such methods,

Verification by Augmented Finitary Abstraction

TLDR
It is shown that by augmenting the system by an appropriate (and standardly constructible) progress monitor, the VFA method is sound and complete for proving all properties expressible by temporal logic (including both safety and liveness).

A Complete Method for the Synthesis of Linear Ranking Functions

TLDR
An automated method for proving the termination of an unnested program loop by synthesizing linear ranking functions is presented and it is shown that if a linear ranking function exists then it will be discovered by the method.

Counterexample-guided abstraction refinement

  • E. Clarke
  • Computer Science
    10th International Symposium on Temporal Representation and Reasoning, 2003 and Fourth International Conference on Temporal Logic. Proceedings.
  • 2003
TLDR
Counterexample-guided abstraction refinement is an automatic abstraction method where the key step is to extract information from false negatives ("spurious counterexamples") due to over-approximation.

Software model checking of liveness properties via transition invariants

TLDR
The results are a characterization of the validity of a liveness property by the existence of transition invariant, and a method that uses transition predicate abstraction to compute transition invariants and thus prove liveness properties for infinite-state programs.

A Platform for Combining Deductive with Algorithmic Verification

TLDR
A computer-aided verification system which combines deductive with algorithmic (model-checking) verification methods, and can verify finite-state systems relative to linear temporal logic (ltl) as well as ctl specifications.

Temporal Verification Diagrams

TLDR
This paper presents a self-contained presentation of verification diagrams for proving various temporal properties of reactive programs with state formulas that contain no temporal operators.

Checking that finite state concurrent programs satisfy their linear specification

TLDR
An algorithm for checking satisfiability of a linear time temporal logic formula over a finite state concurrent program and a formal proof in case the formula is valid over the program is presented.