Abstract
Ensuring correctness of software by formal methods is a very relevant and widely studied problem. Automatic verification of software using model checking suffers from the state space explosion problem. Abstraction is emerging as the key candidate for making the model checking problem tractable, and a large body of research exists on abstraction based verification. Many useful abstractions are performed at the syntactic and semantic levels of programs and their representations.
In this paper, we explore abstraction based verification techniques that have been used at the program source code level. We provide a brief survey of these program transformation techniques. We also examine, in some detail, Program Slicing, an abstraction technique that holds great promise when dealing with complex software. We introduce the idea of using more specialized forms of slicing, Conditioned Slicing and Amorphous Slicing, as program transformation based abstractions for model checking. Experimental results using conditioned slicing for verifying safety properties written in temporal logic show the promise of these techniques.
Chapter PDF
Similar content being viewed by others
Keywords
References
Alur, Rajeev, Henzinger, Thomas A., and Ho, Pei-Hsin (1993). Automatic symbolic verification of embedded systems. In IEEE Real-Time Systems Symposium, pages 2–11.
Avizenis, A. and Laprie, J. (1986). Dependable computing: From concepts to design diversity. Proceedings of the IEEE, 74:629–638.
Avizienis, A. (1997). Toward systematic design of fault-tolerant systems. Computer, 30(4):51–58.
Avizienis, A. and Kelly, J. P. J. (1984). Fault tolerance by design diversity: Concepts and experiments. pages 67–80.
Balarin, F. and Sangiovanni-Vincentelli, A. L. (1993). An iterative approach to language containment. In Proceedings of the 5th International Conference on Computer Aided Verification, pages 29–40.
Ball, Thomas and Rajamani, Sriram K. (2000). Bebop: A symbolic model checker for boolean programs. In SPIN, pages 113–130.
Ball, Thomas and Rajamani, Sriram K. (2001). Automatically validating temporal safety properties of interfaces. Lecture Notes in Computer Science, 2057:103–122.
Bensalem, Saddek, Graf, Susanne, and Lakhnech, Yassine (2003). Abstraction as the key for invariant verification. In Symposium on Verification celebrating Zohar Manna’s 64th Birthday.
Bensalem, Saddek, Lakhnech, Yassine, and Owre, Sam (1998). Computing abstractions of in finite state systems compositionally and automatically. In Computer-Aided Verification, CAV’ 98, volume 1427, pages 319–331.
Bharadwaj, R. and Heitmeyer, C. L. (1999). Model checking complete requirements specifications using abstraction. Automated Software Engineering: An International Journal, 6(1):37–68.
Bryant, R. E., German, S., and Velev, M. N. (2001). Processor verification using efficient reductions of the logic of uninterpreted functions to propositional logic. ACM Trans. Comput. Logic, 2(1):93–134.
Cabodi, G., Camurati, P., and Quer, S. (1994). Symbolic exploration of large circuits with enhanced forward/backward traversals. In Proceedings of the conference on European design automation, pages 22–27.
Canfora, G., Cimitile, A., and Lucia, A. De (1998). Conditioned program slicing. Information and Software Technology Special Issue on Program Slicing, 40:595–607.
Chou, C. and Peled, D. (1996). Formal verification of a partial-order reduction technique for model checking. In Tools and Algorithms for Construction and Analysis of Systems, pages 241–257.
Clarke, E. M., Emerson, E. A., and Sistla, A. P. (1986). Automatic verification of finite state concurrent system using temporal logic specifications: a practical approach. ACM Trans. Program. Lang. Syst., 8(2):244–263.
Clarke, E. M., Grumberg, O., Jha, S., Lu, Y., and Veith, H. (2000). Counterexample-guided abstraction refinement. In Computer Aided Verification, pages 154–169.
Clarke, Edmund M., Grumberg, Orna, and Long, David E. (1994). Model checking and abstraction. ACM Transactions on Programming Languages and Systems, 16(5): 1512–1542.
Colon, Michael and Uribe, Tomas E. (1998). Generating finite-state abstractions of reactive systems using decision procedures. In Computer Aided Verification, pages 293–304.
Corbett, James C., Dwyer, Matthew B., Hatcliff, John, Laubach, Shawn, Păsăreanu, Corina S., Robby, and Zheng, Hongjun (2000). Bandera: extracting finite-state models from Java source code. In International Conference on Software Engineering, pages 439–448.
Cousot, P. (2001). Abstract interpretation based formal methods and future challenges, invited paper. In Informatics — 10 Years Back, 10 Years Ahead, volume 2000 of Lecture Notes in Computer Science, pages 138–156.
Cousot, P. (2003). Automatic verification by abstract interpretation, invited tutorial. In Proceedings of the Fourth International Conference on Verification, Model Checking and Abstract Interpretation (VMCAI2003), pages 20–24.
Cousot, P. and Cousot, R. (1977). Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints. In Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages, pages 238–252.
Cousot, P. and Cousot, R. (1999). Refining model checking by abstract interpretation. Automated Software Engineering, 6(1):69–95.
Dams, D. (1996). Abstract Interpretation and Partition Refinement for Model Checking. PhD thesis, Eindhoven University of Technology.
Dams, D., Gerth, R., and Grumberg, O. (1997). Abstract interpretation of reactive systems. ACM Trans. Program. Lang. Syst., 19(2):253–291.
Dams, D., Hesse, W., and Holzmann, G. J. Abstracting C with abC. pages 515–520.
Danicic, S., Fox, C., Harman, M., and Hierons, R. (2000). Consit: A conditioned program slicer. pages 216–226.
Daoudi, M., Ouarbya, L., Howroyd, J., Danicic, S., Marman, Mark, Fox, Chris, and Ward, M. P. (2002). Consus: A scalable approach to conditional slicing. In IEEE Proceedings of the Working Conference on Reverse Engineering, pages 181–189.
Das, S., Dill, D., and Park, S. (1999). Experience with predicate abstraction. In Computer Aided Verification, pages 160–171.
Dwyer, M. B., Hatcliff, J., Joehanes, R., Laubach, S., Pasareanu, C. S., Robby, Zheng, H., and Visser, W. (2001). Tool-supported program abstraction for finite-state verification. In International Conference on Software Engineering, pages 177–187.
Emerson, E. Allen and Sistla, A. Prasad (1996). Symmetry and model checking. Formal Methods in System Design: An International Journal, 9(1/2):105–131.
Govindaraju, S. G. and Dill, D. L. (1998). Verification by approximate forward and backward reachability. In Proceedings of the 1998 IEEE/ACM international conference on Computeraided design, pages 366–370. ACM Press.
Govindaraju, Shankar G. and Dill, David L. (2000). Counterexample-guided choice of projections in approximate symbolic model checking. In Proceedings of the 2000 IEEE/ACM international conference on Computer-aided design, pages 115–119.
Graf, S. and Saidi, H. (1997). Construction of abstract state graphs with pvs. In Proceedings of the 9th International Conference on Computer Aided Verification, pages 72–83.
Harman, M., Binkley, D., and Danicic, S. (2003). Amorphous program slicing. Journal of Systems and Software, 68(1):45–64.
Hatcliff, J., Dwyer, M. B., and Zheng, H. (2000). Slicing software for model construction. Higher-Order and Symbolic Computation, 13(4):315–353.
H. Cho, G. Hachtel, E. Macii, B. Pleisser, and F. Somenzi (1996). Algorithms for approximate fsm traversal based on state space decomposition. IEEE TCAD, 15(12): 1465–1478.
Henzinger, T. A., Jhala, R., Majumdar, R., and Sutre, G. (2002). Lazy abstraction. In Symposium on Principles of Programming Languages, pages 58–70.
Henzinger, T. A., Jhala, R., Majumdar, R., and Sutre, G. (2003). Software verification with blast. In Proceedings of the Tenth International Workshop on Model Checking of Software (SPIN), pages 235–239. Lecture Notes in Computer Science 2648, Springer-Verlag.
Holzmann, G. J. and Smith, M. H. (2000). Automating software feature verification. Bell Labs Technical Journal, 5(2):72–87.
Korel, B. and Laski, J. (1988). Dynamic program slicing. Inf. Process. Lett., 29(3): 155–163.
Korel, B. and Laski, J. (1990). Dynamic slicing of computer programs. Journal of Systems and Software, 13(3):187–195.
Kozen, D. (1998). Results on the propositional mu-calculus. In Theoretical Computer Science, volume 27, pages 333–354.
Kurshan, R. P. (1990). Analysis of discrete event coordination. In Proceedings on Stepwise refinement of distributed systems: models, formalisms, correctness, pages 414–453.
Kurshan, R. P. (1994). Computer-aided verification of coordinating processes: the automatatheoretic approach. Princeton University Press.
Lafuente, Alberto Lluch (2002). Database of promela models. http://www.informatik.uni-freiburg.de/~lafuente/models/models.html.
Lee, W., Pardo, A., Jang, J., Hachtel, G., and Somenzi, F. (1996). Tearing based automatic abstraction for ctl model checking. In Proceedings of the 1996 IEEE/ACM international conference on Computer-aided design, pages 76–81.
Lichtenstein, O. and Pnueli, A. (1985). Checking that finite state concurrent programs satisfy their linear specification. In Proceedings of the 12th ACM SIGACT-SIGPLAN symposium on Principles of programming languages, pages 97–107.
Lind-Nielsen, J. and Andersen, H. (1999). Stepwise CTL model checking of state/event systems. In CAV’99: Computer Aided Verification.
Loiseaux, C., Graf, S., Sifakis, J., Bouajjani, A., and Bensalem, S. (1995). Property preserving abstractions for the verification of concurrent systems. Formal Methods in System Design, 6(1):11–44.
Manna, Z. and Pnueli, A. (1992). The Temporal Logic of Reactive and Concurrent Systems: Specification. Springer-Verlag.
Millett, L. and Teitelbaum, T. (1998). Slicing promela and its applications to model checking.
Milner, R. (1971). An algebraic definition of simulation between programs. In Proceedings of the 2nd International Joint Conference on Artificial Intelligence., pages 481–489.
Moundanos, Dinos, Abraham, Jacob A., and Hoskote, Yatin V. (1998). Abstraction techniques for validation coverage analysis and test generation. IEEE Trans. Comput., 47(1):2–14.
Namjoshi, K. S. and Kurshan, R. P. (2000). Syntactic program transformations for automatic abstraction. In Computer Aided Verification, pages 435–449.
Ottenstein, K. J. and Ottenstein, L.M. (1984). The program dependence graph in software development environments. SIGPLAN Notices, 19(5):177–184.
Pardo, A. and Hachtel, G. (1998). Incremental CTL model checking using BDD subsetting. In Proceedings of the Design Automation Conference.
Pardo, Abelardo (1997). Automatic Abstraction Techniques for Formal Verification of Digital Systems. PhD thesis, University of Colorado at Boulder.
Park, D. (1981). Concurrency and automata on infinite sequences. In Proceedings of the 5th GI-Conference on Theoretical Computer Science, pages 167–183. Springer-Verlag.
P. Wolfer and V. Lovinfosse (1990). Verifying properties of large sets of processes with network invariants. 407:68–80.
S. Graf and H. Saidi (1997). Construction of abstract state graphs with PVS. In Proc. 9th INternational Conference on Computer Aided Verification (CAV’97), volume 1254, pages 72–83.
Sifakis, J. (1983). Property preserving homomorphisms of transition systems. Lecture Notes in Computer Science, 164:458–473.
Tip, F. (1995). Generation of Program Analysis Tools. PhD thesis.
Venkatesh, G. A. (1991). The semantic approach to program slicing. ACM SIGPLAN Conf. on Programming Language Design and Implementation, 26(6):107–119.
Weiser, M. (1979). Program slices: formal, psychological, and practical investigations of an automatic program abstraction method. PhD thesis.
Weiser, M. (1984). Program slicing. IEEE Transactions on Software Engineering, 10(4):352–357.
Author information
Authors and Affiliations
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2004 Springer Science + Business Media, Inc.
About this paper
Cite this paper
Vasudevan, S., Abraham, J.A. (2004). Static Program Transformations for Efficient Software Model Checking. In: Jacquart, R. (eds) Building the Information Society. IFIP International Federation for Information Processing, vol 156. Springer, Boston, MA. https://doi.org/10.1007/978-1-4020-8157-6_23
Download citation
DOI: https://doi.org/10.1007/978-1-4020-8157-6_23
Publisher Name: Springer, Boston, MA
Print ISBN: 978-1-4020-8156-9
Online ISBN: 978-1-4020-8157-6
eBook Packages: Springer Book Archive