Skip to main content
SpringerLink
Log in

Towards the Complexity Analysis of Programming Language Proof Methods

  • Conference paper
  • First Online:
Theoretical Aspects of Computing – ICTAC 2023 (ICTAC 2023)

Part of the book series: Lecture Notes in Computer Science ((LNCS,volume 14446))

Included in the following conference series:

Abstract

Numerous proof methods have been proposed to establish language properties such as type soundness, confluence, strong normalization, and others. However, literature does not provide a study of the complexity of carrying out these proof methods.

This paper provides an investigation on the complexity of carrying out the “syntactic approach” to type soundness (progress theorem and type preservation theorem) for a class of functional languages, and characterizes the complexity of its proofs as a function of the number of expression constructors, number of typing rules, reduction rules, and other common quantities of operational semantics. Although we do not claim to provide the complexity of this approach, this paper provides the first example of complexity analysis of a programming language proof method.

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

Access this chapter

Log in via an institution
Chapter
USD 29.95
Price excludes VAT (USA)
  • Available as PDF
  • Read on any device
  • Instant download
  • Own it forever
eBook
USD 59.99
Price excludes VAT (USA)
  • Available as EPUB and PDF
  • Read on any device
  • Instant download
  • Own it forever
Softcover Book
USD 79.99
Price excludes VAT (USA)
  • Compact, lightweight edition
  • Dispatched in 3 to 5 business days
  • Free shipping worldwide - see info

Tax calculation will be finalised at checkout

Purchases are for personal use only

Institutional subscriptions

Notes

  1. 1.

    https://softwarefoundations.cis.upenn.edu/.

References

  1. Accattoli, B., Dal Lago, U., Vanoni, G.: The (in)efficiency of interaction. Proc. ACM Program. Lang. (PACMPL) 5(POPL), 1–33 (2021). https://doi.org/10.1145/3434332

  2. Altenkirch, T., Reus, B.: Monadic presentations of lambda terms using generalized inductive types. In: Flum, J., Rodriguez-Artalejo, M. (eds.) CSL 1999. LNCS, vol. 1683, pp. 453–468. Springer, Heidelberg (1999). https://doi.org/10.1007/3-540-48168-0_32

    Chapter  Google Scholar 

  3. Bach Poulsen, C., Rouvoet, A., Tolmach, A., Krebbers, R., Visser, E.: Intrinsically-typed definitional interpreters for imperative languages. Proc. ACM Programm. Lang. (PACMPL) 2(POPL), 1–34 (2017). https://doi.org/10.1145/3158104

  4. Baelde, D., et al.: Abella: a system for reasoning about relational specifications. J. Formalized Reason. 7(2), 1–89 (2014). https://doi.org/10.6092/issn.1972-5787/4650

    Article  MathSciNet  MATH  Google Scholar 

  5. Bellantoni, S.J., Cook, S.A.: A new recursion-theoretic characterization of the polytime functions (extended abstract). In: Proceedings of the Twenty-Fourth Annual ACM Symposium on Theory of Computing, pp. 283–293. STOC 1992, Association for Computing Machinery, New York, NY, USA (1992). https://doi.org/10.1145/129712.129740

  6. Cheney, J.: Toward a general theory of names: binding and scope. In: Pollack, R. (ed.) Proceedings of the 3rd ACM SIGPLAN Workshop on Mechanized Reasoning about Languages with Variable Binding, pp. 33–40. MERLIN 2005, Association for Computing Machinery, New York, NY, USA (2005). https://doi.org/10.1145/1088454.1088459

  7. Church, A.: A formulation of the simple theory of types. J. Symb. Log. 5, 56–68 (1940). https://doi.org/10.2307/2266170

    Article  MathSciNet  MATH  Google Scholar 

  8. Cimini, M.: Lang-n-prove: a DSL for language proofs. In: Proceedings of the 15th ACM SIGPLAN International Conference on Software Language Engineering, pp. 16–29. SLE 2022, Association for Computing Machinery, New York, NY, USA (2022). https://doi.org/10.1145/3567512.3567514

  9. Cimini, M.: A query language for language analysis. In: Schlingloff, B.H., Chai, M. (eds.) SEFM 2022. LNCS, vol. 13550, pp. 57–73. Springer, Cham (2022). https://doi.org/10.1007/978-3-031-17108-6_4

    Chapter  Google Scholar 

  10. Cimini, M., Miller, D., Siek, J.G.: Extrinsically typed operational semantics for functional languages. In: Lämmel, R., Tratt, L., de Lara, J. (eds.) Proceedings of the 13th ACM SIGPLAN International Conference on Software Language Engineering, SLE 2020, Virtual Event, USA, 16–17 November 2020, pp. 108–125. ACM (2020). https://doi.org/10.1145/3426425.3426936

  11. Dummett, M.: Frege: Philosophy of Language, 2nd edn. Harvard University Press, Cambridge (1993)

    MATH  Google Scholar 

  12. Grewe, S., Erdweg, S., Wittmann, P., Mezini, M.: Type systems for the masses: deriving soundness proofs and efficient checkers. In: Murphy, G.C., Steele Jr., G.L. (eds.) 2015 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (Onward!), pp. 137–150. Onward! 2015, ACM, New York, NY, USA (2015). https://doi.org/10.1145/2814228.2814239

  13. Harper, R.: Practical Foundations for Programming Languages. 2 edn. Cambridge University Press, Cambridge (2016). https://doi.org/10.1017/CBO9781316576892

  14. Harper, R., Stone, C.: A type-theoretic interpretation of standard ML. In: Plotkin, G., Stirling, C., Tofte, M. (eds.) Proof, Language, and Interaction: Essays in Honor of Robin Milner. MIT Press (2000). https://doi.org/10.5555/345868.345906

  15. Jones, N.D.: LOGSPACE and PTIME characterized by programming languages. Theor. Comput. Sci. 228(1–2), 151–174 (1999). https://doi.org/10.1016/S0304-3975(98)00357-0

    Article  MathSciNet  MATH  Google Scholar 

  16. Kokke, W., Siek, J.G., Wadler, P.: Programming language foundations in Agda. Sci. Comput. Program. 194, 102440 (2020). https://doi.org/10.1016/j.scico.2020.102440

    Article  Google Scholar 

  17. Leivant, D., Marion, J.-Y.: Lambda calculus characterizations of poly-time. In: Bezem, M., Groote, J.F. (eds.) TLCA 1993. LNCS, vol. 664, pp. 274–288. Springer, Heidelberg (1993). https://doi.org/10.1007/BFb0037112

    Chapter  MATH  Google Scholar 

  18. Milner, R.: A theory of type polymorphism in programming. J. Comput. Syst. Sci. 17(3), 348–375 (1978). https://doi.org/10.1016/0022-0000(78)90014-4

    Article  MathSciNet  MATH  Google Scholar 

  19. Pfenning, F.: Lecture notes on harmony (lecture 3) 15–317: constructive logic (2009). https://www.cs.cmu.edu/~fp/courses/15317-f09/lectures/03-harmony.pdf

  20. Pfenning, F., Schürmann, C.: System description: Twelf — a meta-logical framework for deductive systems. In: CADE 1999. LNCS (LNAI), vol. 1632, pp. 202–206. Springer, Heidelberg (1999). https://doi.org/10.1007/3-540-48660-7_14

    Chapter  Google Scholar 

  21. Pierce, B.C.: Types and Programming Languages. MIT Press, Cambridge (2002)

    MATH  Google Scholar 

  22. Pottier, F., Simonet, V.: Information flow inference for ML. In: Proceedings of the 29th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pp. 319–330. POPL 2002, Association for Computing Machinery, New York, NY, USA (2002). https://doi.org/10.1145/503272.503302

  23. van der Rest, C., Poulsen, C.B., Rouvoet, A., Visser, E., Mosses, P.: Intrinsically-typed definitional interpreters à la carte. Proc. ACM Program. Lang. (PACMPL) 6(OOPSLA2), 1903–1932 (2022). https://doi.org/10.1145/3563355

  24. Tait, W.W.: Intensional interpretations of functionals of finite type I. J. Symb. Log. 32(2), 198–212 (1967). https://doi.org/10.2307/2271658

    Article  MathSciNet  MATH  Google Scholar 

  25. Thiemann, P.: Intrinsically-typed mechanized semantics for session types. In: Komendantskaya, E. (ed.) Proceedings of the 21st International Symposium on Principles and Practice of Declarative Programming, pp. 19:1–19:15. PPDP 2019, Association for Computing Machinery, New York, NY, USA (2019). https://doi.org/10.1145/3354166.3354184

  26. Volpano, D., Irvine, C., Smith, G.: A sound type system for secure flow analysis. J. Comput. Secur. 4(2–3), 167–187 (1996). https://doi.org/10.3233/JCS-1996-42-304

  27. Wright, A.K., Felleisen, M.: A syntactic approach to type soundness. Inf. Comput. 115(1), 38–94 (1994). https://doi.org/10.1006/inco.1994.1093

    Article  MathSciNet  MATH  Google Scholar 

Download references

Author information

Authors and Affiliations

  1. University of Massachusetts Lowell, Lowell, MA, 01854, USA

    Matteo Cimini

Authors
  1. Matteo Cimini
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to Matteo Cimini .

Editor information

Editors and Affiliations

  1. RWTH Aachen University, Aachen, Germany

    Erika Ábrahám

  2. Eindhoven University of Technology, Eindhoven, The Netherlands

    Clemens Dubslaff

  3. University of Oslo, Oslo, Norway

    Silvia Lizeth Tapia Tarifa

Rights and permissions

Reprints and permissions

Copyright information

© 2023 The Author(s), under exclusive license to Springer Nature Switzerland AG

About this paper

Check for updates. Verify currency and authenticity via CrossMark

Cite this paper

Cimini, M. (2023). Towards the Complexity Analysis of Programming Language Proof Methods. In: Ábrahám, E., Dubslaff, C., Tarifa, S.L.T. (eds) Theoretical Aspects of Computing – ICTAC 2023. ICTAC 2023. Lecture Notes in Computer Science, vol 14446. Springer, Cham. https://doi.org/10.1007/978-3-031-47963-2_8

Download citation

  • DOI: https://doi.org/10.1007/978-3-031-47963-2_8

  • Published:

  • Publisher Name: Springer, Cham

  • Print ISBN: 978-3-031-47962-5

  • Online ISBN: 978-3-031-47963-2

  • eBook Packages: Computer ScienceComputer Science (R0)

Publish with us

Policies and ethics

Search

Navigation