Proof Reduction of Fair Stuttering Refinement of Asynchronous Systems and Applications

@inproceedings{Sumners2017ProofRO,
  title={Proof Reduction of Fair Stuttering Refinement of Asynchronous Systems and Applications},
  author={Robert W. Sumners},
  booktitle={ACL2},
  year={2017}
}
  • R. Sumners
  • Published in ACL2 1 May 2017
  • Computer Science
We present a series of definitions and theorems demonstrating how to reduce the requirements for proving system refinements ensuring containment of fair stuttering runs. A primary result of the work is the ability to reduce the requisite proofs on runs of a system of interacting state machines to a set of definitions and checks on single steps of a small number of state machines corresponding to the intuitive notions of freedom from starvation and deadlock. We further refine the definitions to… 

Figures from this paper

Computing and Proving Well-founded Orderings through Finite Abstractions

A process for computing a finite abstract graph of the target state machine along with annotations on whether certain measures decrease or not on arcs in the abstract graph is developed along with an implementation of the Bakery algorithm as an example application.

Improved Efficiency of Object Code Verification Using Statically Abstracted Object Code

The SSA technique has been proven to be consistent in decreasing the code size significantly and hence the complexity of the implementation transition system and there is considerable reduction in time and effort required for the verification of a complex software control, i.e., pacemaker when statically stuttering abstracted code is employed.

References

SHOWING 1-10 OF 11 REFERENCES

A Theorem Proving Approach for Verification of Reactive Concurrent Programs

A collection of proof rules are presented that can be effectively orchestrated by a theorem prover to reason about complex programs using refinements to support the definition of intuitive specifications of the intended behavior of a program.

Linking Theorem Proving and Model-Checking with Well-Founded Bisimulation

An on-the-fly method that extracts the reachable quotient structure induced by the bisimulation, if the structure is finite, and shows that the alternating bit protocol is a refinement of a non-lossy system.

Proving Skipping Refinement with ACL2s

It is shown how ACL2s can be used to prove skipping refinement theorems by modeling and proving the correctness of three systems: a JVM-inspired stack machine, a simple memory controller, and a scalar to vector compiler transformation.

Compositional Verification of Timed Components using PVS

A compositional proof rule for parallel composition is defined and proved its soundness in PVS and a hiding rule can be applied to hide internal events after composition.

Efficient execution in an automated reasoning environment

A method that permits the user of a mechanized mathematical logic to write elegant logical definitions while allowing sound and efficient execution and the features supporting this method allow the user to install alternative executable counterparts for logically defined functions.

Construction of Abstract State Graphs with PVS

In this paper, we propose a method for the automatic construction of an abstract state graph of an arbitrary system using the Pvs theorem prover.

Computer-Aided Reasoning: An Approach

Computer-Aided Reasoning: ACL2 Case Studies illustrates how the computer-aided reasoning system ACL2 can be used in productive and innovative ways to design, build, and maintain hardware and software systems.

Specification and Verification of Concurrent Programs Through Refinements

A collection of proof rules that can be effectively orchestrated by a theorem prover to reason about complex programs using refinements are presented, which systematically reduce the correctness proof for a concurrent program to the definition and proof of an invariant.

3) 'loaded) ((4 5 6) 'interested) (t 'go)) :pos (case (g :loc a) (3 (g :old-pos a)) (t (g :pos a))) :load (case (g :loc a

  • defun bake-impl-t-map (a) (upd nil :loc (case (g :loc a) ((0 1) 'idle