In temporal-logic model checking, we verify the correctness of a program with respect to a desired behavior by checking whether a structure that models the program satisfies a temporal-logic formula that specifies the behavior. The main practical limitation of model checking is caused by the size of the state space of the program, which grows exponentially with the number of concurrent components. This problem, known as the state-explosion problem, becomes more difficult when we consider real-time model checking, where the program and the specification involve quantitative references to time. In particular, when use timed automata to describe real-time programs and we specify timed behaviors in the logic TCTL, a real-time extension of the temporal logic CTL with clock variables, then the state space under consideration grows exponentially not only with the number of concurrent components, but also with the number of clocks and the length of the clock constraints used in the program and the specification. Two powerful methods for coping with the state-explosion problem are on-the-fly and space-efficient model checking. In on-the-fly model checking, we explore only the portion of the state space of the program whose exploration is essential for determining the satisfaction of the specification. In space-efficient model checking, we store in memory the minimal information required, preferring to spend time on reconstructing information rather than spend space on storing it. In this work we develop an automata-theoretic approach to TCTL model checking that combines both methods. We suggest, for the first time, a PSPACE on-the-fly model-checking algorithm for TCTL.
- Model Check
- Temporal Logic
- Linear Temporal Logic
- Region Position
- Tree Automaton
These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.
Supported in part by the ONR YIP award N00014-95-1-0520, by the NSF CAREER award CCR-9501708, by the NSF grant CCR-9504469, by the AFOSR contract F49620-93-1-0056, and by the ARPA grant NAG2-892.
This is a preview of subscription content, access via your institution.
Unable to display preview. Download preview PDF.
R. Alur, C. Courcoubetis, and D. Dill. Model-checking in dense real-time. Information and Computation, 104(1):2–34, May 1993.
R. Alur and D. Dill. A theory of timed automata. Theoretical Computer Science, 126(2):183–236, 1994.
R. Alur, T. Feder, and T.A. Henzinger. The benefits of relaxing punctuality. Journal of the ACM, 43(1):116–146, 1996.
R. Alur and T.A. Henzinger. Logics and models of real time: a survey. In J.W. de Bakker, K. Huizing, W.-P. de Roever, and G. Rozenberg, editors, Real Time: Theory in Practice, Lecture Notes in Computer Science 600, pages 74–106. Springer-Verlag, 1992.
R. Alur and T. Henzinger. Real-time logics: Complexity and expressiveness. Information and Computation, 104(1):35–77, May 1993.
R. Alur and T.A. Henzinger. A really temporal logic. Journal of the ACM, 41(1):181–204, 1994.
R. Alur. Techniques for Automatic Verification of Real-time Systems. PhD thesis, Stanford University, 1991.
O. Bernholtz, M.Y. Vardi, and P. Wolper. An automata-theoretic approach to branchingtime model checking. In D. L. Dill, editor, Computer Aided Verification, Proc. 6th Int. Conference, volume 818 of Lecture Notes in Computer Science, pages 142–155, Stanford, June 1994. Springer-Verlag.
E.M. Clarke and E.A. Emerson. Design and synthesis of synchronization skeletons using branching time temporal logic. In Proc. Workshop on Logic of Programs, volume 131 of Lecture Notes in Computer Science, pages 52–71. Springer-Verlag, 1981.
E.M. Clarke, E.A. Emerson, and A.P. Sistla. Automatic verification of finite-state concurrent systems using temporal logic specifications. ACM Transactions on Programming Languages and Systems, 8(2):244–263, January 1986.
C. Courcoubetis, M.Y. Vardi, P. Wolper, and M. Yannakakis. Memory efficient algorithms for the verification of temporal properties. Formal Methods in System Design, 1:275–288, 1992.
E.A. Emerson. Real time and the Μ-calculus. In J.W. de Bakker, K. Huizing, W.-P. de Roever, and G. Rozenberg, editors, Real Time: Theory in Practice, Lecture Notes in Computer Science 600, pages 176–194. Springer-Verlag, 1992.
E.A. Emerson, A.K. Mok, A.P. Sistla, and J. Srinivasan. Quantitative temporal reasoning. In Proc. 2nd Workshop on Computer Aided Verification, volume 531 of Lecture Notes in Computer Science, pages 136–145. Springer-Verlag, 1990.
J.-C. Fernandez, L. Mounier, C. Jard, and T. Jeron. On-the-fly verification of finite transition systems. Formal Methods in System Design, 1:251–273, 1992.
T.A. Henzinger, X. Nicollin, J. Sifakis, and S. Yovine. Symbolic model checking for real-time systems. Information and Computation, 111:193–244, 1994.
O. Kupferman and M.Y. Vardi. On the complexity of branching modular model checking. In Proc. 6th Conferance on Concurrency Theory, pages 408–422, Philadelphia, August 1995.
L. Lamport. Sometimes is sometimes “not never” — on the temporal logic of programs. In Proceedings of the 7th ACM Symposium on Principles of Programming Languages, pages 174–185, January 1980.
F. Laroussinie and K. G. Larsen. Compositional model checking of real time systems. In Proc. 6th Conferance on Concurrency Theory, pages 27–41, Philadelphia, August 1995.
Z. Manna and A. Pnueli. The Temporal Logic of Reactive and Concurrent Systems: Specification. Springer-Verlag, Berlin, January 1992.
D.E. Muller and P.E. Schupp. Alternating automata on infinite trees. Theoretical Computer Science, 54,:267–276, 1987.
D.E. Muller, A. Saoudi, and P.E. Schupp. Alternating automata, the weak monadic theory of the tree and its complexity. In Proc. 13th Int. Colloquium on Automata, Languages and Programming. Springer-Verlag, 1986.
A. Pnueli. The temporal logic of programs. In Proc. 18th IEEE Symposium on Foundation of Computer Science, pages 46–57, 1977.
J.P. Queille and J. Sifakis. Specification and verification of concurrent systems in Cesar. In Proc. 5th International Symp. on Programming, volume 137, pages 337–351. Springer-Verlag, Lecture Notes in Computer Science, 1981.
A.P. Sistla and E.M. Clarke. The complexity of prepositional linear temporal logic. J. ACM, 32:733–749, 1985.
O.V. Sokolsky and S.A. Smolka. Local model checking for real-time systems. In Computer Aided Verification, Proc. 7th Int. Workshop, Lecture Notes in Computer Science 939, pages 211–224, Liege, July 1995.
C. Stirling and D. Walker. Local model checking in the modal mu-calculus. In Proc. 15th Col. on Trees in Algebra and Programming. Lecture Notes in Computer Science, 1989.
W. Thomas. Automata on infinite objects. Handbook of Theoretical Computer Science, pages 165–191, 1990.
M.Y. Vardi and P. Wolper. Reasoning about infinite computations. Information and Computation, 115(1):1–37, November 1994.
M. Yannakakis and D. Lee. An efficient algorithm for minimizing real-time transition systems. In C. Courcoubetis, editor, Computer Aided Verification, Proc. 5th Int. Workshop, volume 697 of Lecture Notes in Computer Science 697, pages 210–224, Elounda, Crete, June 1993. Lecture Notes in Computer Science, Springer-Verlag.
Editors and Affiliations
Rights and permissions
© 1996 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
Henzinger, T.A., Kupferman, O., Vardi, M.Y. (1996). A space-efficient on-the-fly algorithm for real-time model checking. In: Montanari, U., Sassone, V. (eds) CONCUR '96: Concurrency Theory. CONCUR 1996. Lecture Notes in Computer Science, vol 1119. Springer, Berlin, Heidelberg. https://doi.org/10.1007/3-540-61604-7_73
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-540-61604-7
Online ISBN: 978-3-540-70625-0
eBook Packages: Springer Book Archive