Skip to main content
SpringerLink
Log in

The Branching-Time Transformation Technique for Chain Datalog Programs

  • Published:
Journal of Intelligent Information Systems Aims and scope Submit manuscript

Abstract

The branching-time transformation technique has proven to be an efficient approach for implementing functional programming languages. In this paper we demonstrate that such a technique can also be defined for logic programming languages. More specifically, we first introduce Branching Datalog, a language that can be considered as the basis for branching-temporal deductive databases. We then present a transformation algorithm from Chain Datalog programs to the class of unary Branching Datalog programs with at most one IDB atom in the body of each clause. In this way, we obtain a novel implementation approach for Chain Datalog, shedding at the same time new light on the power of branching-time logic programming.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Log in via an institution

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Similar content being viewed by others

References

  • Afrati, F. and Cosmadakis, S. (1989). Expressiveness of Restricted Recursive Queries. In Proc. 21st ACM Symp. on Theory of Computing

  • Afrati, F., Gergatsoulis, M., and Katzouraki, M. (1996). On Transformations into Linear Database Logic Programs. In D. Bjørner, M. Broy and I. Pottosin (Eds.), Perspectives of Systems Informatics (PSI'96), Proceedings (pp. 433-444).

  • Afrati, F. and Papadimitriou, C.H. (1987). The Parallel Complexity of Simple Chain Queries. In Proc. 6th ACM Symposium on Principles of Database Systems (pp. 210-213).

  • Afrati, F. and Papadimitriou, C.H. (1993). Parallel Complexity of Simple Logic Programs, Journal of the ACM, 40(3), 891-916.

    Google Scholar 

  • Baudinet, M., Chomicki, J., and Wolper, P. (1993). Temporal Deductive Databases. In L.F. del Cerro and M. Penttonen (Eds.), Temporal Databases: Theory, Design, and Implementation (pp. 294-320). The Benjamin/Cummings Publishing Company, Inc.

  • Beeri, C. and Ramakrishnan, R. (1991). On the power of magic, The Journal of Logic Programming, 10(1-4), 255-299.

    Google Scholar 

  • Chomicki, J. (1995). Depth-Bounded Bottom-Up evaluation of Logic Programs, The Journal of Logic Programming, 25(1), 1-31.

    Google Scholar 

  • Dong, G. and Ginsburg, S. (1995). On Decompositions of Chain Datalog Programs into ρ (Left-)Linear 1-Rule Components, The Journal of Logic Programming, 23(3), 203-236.

    Google Scholar 

  • Du, W. and Wadge, W.W. (1990). The Eductive Implementation of a Three-dimensional Spreadsheet, Software-Practice and Experience, 20(11), 1097-1114.

    Google Scholar 

  • Faustini, A. and Wadge, W. (1987). An Eductive Interpreter for the Language pLucid. In Proceedings of the SIGPLAN 87 Conference on Interpreters and Interpretive Techniques (SIGPLAN Notices 22(7)) (pp. 86-91).

    Google Scholar 

  • Gergatsoulis, M. (2001). Temporal and Modal Logic Programming Languages. In A. Kent and J.G. Williams (Eds.), Encyclopedia of Microcomputers, Vol. 27, Suppl. 6. Marcel Decker, Inc., pp. 393-408.

  • Gergatsoulis, M. and Katzouraki, M. (1994). Unfold/Fold Transformations for Definite Clause Programs. In M. Hermenegildo and J. Penjam (Eds.), Programming Language Implementation and Logic Programming (PLILP'94), Proceedings (pp. 340-354).

  • Gergatsoulis, M. and Spyropoulos, C. (1998). Transformation Techniques for Branching-Time Logic Programs. In W.W. Wadge (Ed.), Proc. of the 11th International Symposium on Languages for Intensional Programming (ISLIP'98), May 7–9, Palo Alto, California, USA (pp. 48-63).

  • Greco, S., Saccà, D., and Zaniolo, C. (1999). Grammars and Automata to Optimize Chain Logic Queries, International Journal on Foundations of Computer Science, 10(3), 349-372.

    Google Scholar 

  • Haddad, R.W. and Naughton, J.F. (1988). Counting Methods for Cyclic Relations. In Proc. 7th ACM SIGACTSIGMOD-SIGART Symposium on Principles of Database Systems (pp. 333-340).

  • Jones, S.L.P. (1987). The Implementation of Functional Programming Languages. Prentice-Hall.

  • Lloyd, J.W. (1987). Foundations of Logic Programming. Springer-Verlag, Germany.

    Google Scholar 

  • Naughton, J.F. and Ramakrishnan, R. (1991). Bottom-Up Evaluation of Logic Programs. In J.L. Lasser and G. Plotkin (Eds.), Computational Logic. Essays in the Honor of Alan Robinson (pp. 640-699). MIT Press.

  • Orgun, M.A. (1991). Intensional Logic Programming. Ph.D. Thesis, Dept. of Computer Science, University of Victoria, Canada.

    Google Scholar 

  • Orgun, M.A. (1996). On Temporal Deductive Databases, Computational Intelligence, 12(2), 235-259.

    Google Scholar 

  • Orgun, M.A. and Ma,W. (1994). An Overview of Temporal and Modal Logic Programming. In D.M. Gabbay and H.J. Ohlbach (Eds.), Proc. of the First International Conference on Temporal Logics (ICTL'94) (pp. 445-479).

  • Proietti, M. and Pettorossi, A. (1990). Synthesis of Eureka Predicates for Developing Logic Programs. In Proc. of the 3rd European Symposium on Programming (pp. 306-325).

  • Rondogiannis, P., Gergatsoulis, M., and Panayiotopoulos, T. (1998). Branching-Time Logic Programming: The Language Cactus and Its Applications, Computer Languages, 24(3), 155-178.

    Google Scholar 

  • Rondogiannis, P. and Wadge, W.W. (1997). First-Order Functional Languages and Intensional Logic, Journal of Functional Programming, 7(1), 73-101.

    Google Scholar 

  • Rondogiannis, P. and Wadge, W.W. (1999). Higher-Order Functional Languages and Intensional Logic, Journal of Functional Programming, 9(5), 527-564.

    Google Scholar 

  • Saccà, D. and Zaniolo, C. (1988). The Generalized Counting Method for Recursive Logic Queries, Theoretical Computer Science, 4(4), 187-220.

    Google Scholar 

  • Sippu, S. and Soisalon-Soininen, E. (1996). An Analysis of Magic Sets and Related Optimization Strategies for Logic Queries, Journal of the ACM, 43(6), 1046-1088.

    Google Scholar 

  • Tamaki, H. and Sato, T. (1984). Unfold/Fold Transformations of Logic Programs. In S.-Å. Tarnlund (Ed.), Proc. of the Second International Conference on Logic Programming (pp. 127-138).

  • Ullman, J.D. (1989). Principles of Database and Knowledge-Base Systems, Vols. I & II. Computer Science Press, USA.

    Google Scholar 

  • Ullman, J.D. and Gelder, A.V. (1988). Parallel Complexity of Logical Query Programs, Algorithmica, 3, 5-42.

    Google Scholar 

  • Wadge, W.W. (1991). Higher-Order Lucid. In Proceedings of the Fourth International Symposium on Lucid and Intensional Programming.

  • Yaghi, A. (1984). The Intensional Implementation Technique for Functional Languages. Ph.D. Thesis, Dept. of Computer Science, University of Warwick, Coventry, UK.

    Google Scholar 

Download references

Author information

Authors and Affiliations

  1. Dept. of Informatics and Telecommunications, University of Athens, 15784, Athens, Greece

    Panos Rondogiannis

  2. National Centre for Scientific Research (NCSR) ‘Demokritos’, Inst. of Informatics and Telecommunications, 15310 A. Paraskevi Attikis, Athens, Greece

    Manolis Gergatsoulis

Authors
  1. Panos Rondogiannis
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Manolis Gergatsoulis
    View author publications

    You can also search for this author in PubMed Google Scholar

Rights and permissions

Reprints and permissions

About this article

Cite this article

Rondogiannis, P., Gergatsoulis, M. The Branching-Time Transformation Technique for Chain Datalog Programs. Journal of Intelligent Information Systems 17, 71–94 (2001). https://doi.org/10.1023/A:1012502800961

Download citation

  • Issue Date:

  • DOI: https://doi.org/10.1023/A:1012502800961

Search

Navigation