research-article

Open access

Separation logic for sequential programs (functional pearl)

Author:

Arthur CharguéraudAuthors Info & Claims

Proceedings of the ACM on Programming Languages, Volume 4, Issue ICFP

Article No.: 116, Pages 1 - 34

https://doi.org/10.1145/3408998

Published: 03 August 2020 Publication History

Abstract

This paper presents a simple mechanized formalization of Separation Logic for sequential programs. This formalization is aimed for teaching the ideas of Separation Logic, including its soundness proof and its recent enhancements. The formalization serves as support for a course that follows the style of the successful Software Foundations series, with all the statement and proofs formalized in Coq. This course only assumes basic knowledge of lambda-calculus, semantics and logics, and therefore should be accessible to a broad audience.

Supplementary Material

Presentation at ICFP '20 (a116-chargueraud-presentation.mp4)

Download
71.78 MB

References

[1]

Amal Jamil Ahmed. 2004. Semantics of Types for Mutable State. Ph.D. Dissertation. Princeton University.

Digital Library

[2]

Andrew W. Appel. 2011. Verified Software Toolchain. In Proceedings of the 20th European Conference on Programming Languages and Systems: Part of the Joint European Conferences on Theory and Practice of Software (Saarbrücken, Germany) (ESOP'11/ETAPS'11). Springer-Verlag, Berlin, Heidelberg, 1-17. https://doi.org/10.1007/978-3-642-28891-3_2

Digital Library

[3]

Andrew W Appel. 2014. Program logics for certified compilers. Cambridge University Press. https://doi.org/10.1017/ CBO9781107256552 With Robert Dockins, Aquinas Hobor, Lennart Beringer, Josiah Dodds, Gordon Stewart, Sandrine Blazy, and Xavier Leroy.

[4]

Andrew W Appel and Sandrine Blazy. 2007. Separation logic for small-step Cminor. In International Conference on Theorem Proving in Higher Order Logics, Klaus Schneider and Jens Brandt (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 5-21. https://doi.org/10.1007/978-3-540-74591-4_3

[5]

Andrew W. Appel and Qinxiang Cao. 2020. Verifiable C. Software Foundations, Vol. 5beta. Electronic textbook. http://softwarefoundations.cis.upenn. edu Version 0.9.5.

[6]

Andrew W. Appel, Robert Dockins, Aquinas Hobor, Lennart Beringer, Josiah Dodds, Gordon Stewart, Sandrine Blazy, and Xavier Leroy. 2014. Program Logics for Certified Compilers. Cambridge University Press, USA. https://doi.org/10.1017/ CBO9781107256552

[7]

Andrew W. Appel and David McAllester. 2001. An Indexed Model of Recursive Types for Foundational Proof-Carrying Code. ACM Trans. Program. Lang. Syst. 23, 5 (Sept. 2001 ), 657-683. https://doi.org/10.1145/504709.504712

Digital Library

[8]

Andrew W. Appel, Paul-André Melliès, Christopher D. Richards, and Jérôme Vouillon. 2007. A Very Modal Model of a Modern, Major, General Type System. In Proceedings of the 34th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (Nice, France) (POPL '07). Association for Computing Machinery, New York, NY, USA, 109-122. https://doi.org/10.1145/1190216.1190235

Digital Library

[9]

Callum Bannister, Peter Höfner, and Gerwin Klein. 2018. Backwards and Forwards with Separation Logic. In Interactive Theorem Proving, Jeremy Avigad and Assia Mahboubi (Eds.). Springer International Publishing, Cham, 68-87. https: //doi.org/10.1007/978-3-319-94821-8_5

[10]

Jesper Bengtson, Jonas Braband Jensen, and Lars Birkedal. 2012. Charge!. In Interactive Theorem Proving, Lennart Beringer and Amy Felty (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 315-331. https://doi.org/10.1007/978-3-642-32347-8_21

[11]

Jesper Bengtson, Jonas Braband Jensen, Filip Sieczkowski, and Lars Birkedal. 2011. Verifying Object-Oriented Programs with Higher-Order Separation Logic in Coq. In Interactive Theorem Proving, Marko van Eekelen, Herman Geuvers, Julien Schmaltz, and Freek Wiedijk (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 22-38. https://doi.org/10.1007/978-3-642-22863-6_5

[12]

Bodil Biering, Lars Birkedal, and Noah Torp-Smith. 2005. BI Hyperdoctrines and Higher-Order Separation Logic. In Proceedings of the 14th European Conference on Programming Languages and Systems (Edinburgh, UK) (ESOP'05). SpringerVerlag, Berlin, Heidelberg, 233-247. https://doi.org/10.1007/978-3-540-31987-0_17

Digital Library

[13]

Bodil Biering, Lars Birkedal, and Noah Torp-Smith. 2007. BI-Hyperdoctrines, Higher-Order Separation Logic, and Abstraction. ACM Trans. Program. Lang. Syst. 29, 5 (Aug. 2007 ), 24-es. https://doi.org/10.1145/1275497.1275499

Digital Library

[14]

Lars Birkedal and Aleš Bizjak. 2018. Lecture Notes on Iris: Higher-Order Concurrent Separation Logic. https://irisproject.org/tutorial-material.html

[15]

Lars Birkedal, Bernhard Reus, Jan Schwinghammer, and Hongseok Yang. 2008. A Simple Model of Separation Logic for Higher-Order Store. In Automata, Languages and Programming (ICALP), Luca Aceto, Ivan Damgård, Leslie Ann Goldberg, Magnús M. Halldórsson, Anna Ingólfsdóttir, and Igor Walukiewicz (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 348-360. https://doi.org/10.1007/978-3-540-70583-3_29

Digital Library

[16]

Lars Birkedal, Noah Torp-Smith, and Hongseok Yang. 2005. Semantics of separation-logic typing and higher-order frame rules. In 20th Annual IEEE Symposium on Logic in Computer Science (LICS'05). IEEE, 260-269. https://doi.org/10.1109/ LICS. 2005.47

Digital Library

[17]

Lars Birkedal, Noah Torp-smith, and Hongseok Yang. 2006. Semantics of separation-logic typing and higher-order frame rules for algol-like languages, PrakashEditor Panangaden (Ed.). Logical Methods in Computer Science 2, 5. https: //doi.org/10.2168/lmcs-2( 5 :1) 2006

[18]

Lars Birkedal and Hongseok Yang. 2007. Relational Parametricity and Separation Logic. In Foundations of Software Science and Computational Structures, Helmut Seidl (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg, 93-107. https: //doi.org/10.1007/978-3-540-71389-0_8

[19]

Aleš Bizjak, Daniel Gratzer, Robbert Krebbers, and Lars Birkedal. 2019. Iron: Managing Obligations in Higher-Order Concurrent Separation Logic. Proc. ACM Program. Lang. 3, POPL, Article 65 ( Jan. 2019 ), 30 pages. https://doi.org/10. 1145/3290378

Digital Library

[20]

R. M. Burstall. 1972. Some Techniques for Proving Correctness of Programs which Alter Data Structures. In Machine Intelligence 7, B. Meltzer and D. Mitchie (Eds.). Edinburgh University Press, Edinburgh, Scotland., 23-50.

[21]

Hongxu Cai, Zhong Shao, and Alexander Vaynberg. 2007. Certified Self-Modifying Code. SIGPLAN Not. 42, 6 ( June 2007 ), 66-77. https://doi.org/10.1145/1273442.1250743

Digital Library

[22]

Cristiano Calcagno, Dino Distefano, Jeremy Dubreil, Dominik Gabi, Pieter Hooimeijer, Martino Luca, Peter O'Hearn, Irene Papakonstantinou, Jim Purbrick, and Dulma Rodriguez. 2015. Moving Fast with Software Verification. In NASA Formal Methods, Klaus Havelund, Gerard Holzmann, and Rajeev Joshi (Eds.). Springer International Publishing, Cham, 3-11. https://doi.org/10.1007/978-3-319-17524-9_1

[23]

Cristiano Calcagno, Peter W. O'Hearn, and Hongseok Yang. 2007. Local Action and Abstract Separation Logic. In Logic in Computer Science (LICS). 366-378. https://doi.org/10.1109/LICS. 2007.30

Digital Library

[24]

Qinxiang Cao, Lennart Beringer, Samuel Gruetter, Josiah Dodds, and Andrew W Appel. 2018a. VST-Floyd : A separation logic tool to verify correctness of C programs. Journal of Automated Reasoning 61, 1-4 ( 2018 ), 367-422. https://doi.org/ 10.1007/s10817-018-9457-5

Digital Library

[25]

Qinxiang Cao, Shengyi Wang, Aquinas Hobor, and Andrew W. Appel. 2018b. Proof pearl: Magic wand as frame. Unpublished.

[26]

Arthur Charguéraud. 2011. Characteristic Formulae for the Verification of Imperative Programs. In International Conference on Functional Programming (Tokyo, Japan) ( ICFP '11). Association for Computing Machinery, New York, NY, USA, 418-430. https://doi.org/10.1145/2034773.2034828

Digital Library

[27]

Arthur Charguéraud and François Pottier. 2015. Machine-Checked Verification of the Correctness and Amortized Complexity of an Eficient Union-Find Implementation. In Interactive Theorem Proving, Christian Urban and Xingyuan Zhang (Eds.). Springer International Publishing, Cham, 137-153. https://doi.org/10.1007/978-3-319-22102-1_9

[28]

Arthur Charguéraud and François Pottier. 2019. Verifying the Correctness and Amortized Complexity of a Union-Find Implementation in Separation Logic with Time Credits. Journal of Automated Reasoning (JAR) 62, 3 (March 2019 ), 331-365. https://doi.org/10.1007/s10817-017-9431-7

Digital Library

[29]

Arthur Charguéraud. 2010. Characteristic Formulae for Mechanized Program Verification. Ph.D. Dissertation. Université Paris Diderot. http://www.chargueraud.org/research/2010/thesis/thesis_final.pdf

[30]

Arthur Charguéraud. 2020. Supplementary material. http://www.chargueraud.org/teach/verif/

[31]

Arthur Charguéraud and François Pottier. 2017. Temporary Read-Only Permissions for Separation Logic. In European Symposium on Programming (ESOP) (Lecture Notes in Computer Science, Vol. 10201 ), Hongseok Yang (Ed.). Springer, 260-286. https://doi.org/10.1007/978-3-662-54434-1_10

[32]

Haogang Chen, Daniel Ziegler, Tej Chajed, Adam Chlipala, M. Frans Kaashoek, and Nickolai Zeldovich. 2015. Using Crash Hoare Logic for Certifying the FSCQ File System. In Proceedings of the 25th Symposium on Operating Systems Principles (Monterey, California) ( SOSP '15). Association for Computing Machinery, New York, NY, USA, 18-37. https: //doi.org/10.1145/2815400.2815402

Digital Library

[33]

Adam Chlipala. 2011. Mostly-Automated Verification of Low-Level Programs in Computational Separation Logic. SIGPLAN Not. 46, 6 ( June 2011 ), 234-245. https://doi.org/10.1145/1993316.1993526

Digital Library

[34]

Adam Chlipala. 2013. The Bedrock Structured Programming System: Combining Generative Metaprogramming and Hoare Logic in an Extensible Program Verifier, In Proceedings of the 18th ACM SIGPLAN International conference on Functional programming. SIGPLAN Not. 48, 9, 391-402. https://doi.org/10.1145/2544174.2500592

Digital Library

[35]

Adam Chlipala. 2015. From Network Interface to Multithreaded Web Applications: A Case Study in Modular Program Verification. SIGPLAN Not. 50, 1 (Jan. 2015 ), 609-622. https://doi.org/10.1145/2775051.2677003

Digital Library

[36]

Adam Chlipala. 2018a. Formal reasoning about programs. http://adam.chlipala.net/frap/frap_book. pdf Course notes.

[37]

Adam Chlipala. 2018b. Formal reasoning about programs, Coq material for Chapter 14. https://github.com/achlipala/frap/ blob/master/SeparationLogic.v

[38]

Adam Chlipala, Gregory Malecha, Greg Morrisett, Avraham Shinnar, and Ryan Wisnesky. 2009. Efective Interactive Proofs for Higher-Order Imperative Programs. In ACM International Conference on Functional Programming ( ICFP) (Edinburgh, Scotland) (ICFP '09). Association for Computing Machinery, New York, NY, USA, 79-90. https://doi.org/10.1145/1596550. 1596565

Digital Library

[39]

David Costanzo and Zhong Shao. 2012. A Case for Behavior-Preserving Actions in Separation Logic. In Programming Languages and Systems, Ranjit Jhala and Atsushi Igarashi (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 332-349. https://doi.org/10.1007/978-3-642-35182-2_24

[40]

Robert Dockins, Andrew W. Appel, and Aquinas Hobor. 2008. Multimodal Separation Logic for Reasoning About Operational Semantics. Electronic Notes in Theoretical Computer Science 218 ( 2008 ), 5-20. https://doi.org/10.1016/j.entcs. 2008. 10. 002 Proceedings of the 24th Conference on the Mathematical Foundations of Programming Semantics (MFPS XXIV).

Digital Library

[41]

Robert Dockins, Aquinas Hobor, and Andrew W. Appel. 2009. A Fresh Look at Separation Algebras and Share Accounting. In Programming Languages and Systems, Zhenjiang Hu (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg, 161-177. https://doi.org/10.1007/978-3-642-10672-9_13

Digital Library

[42]

Xinyu Feng, Zhaozhong Ni, Zhong Shao, and Yu Guo. 2007. An Open Framework for Foundational Proof-Carrying Code. In Proc. 2007 ACM SIGPLAN International Workshop on Types in Language Design and Implementation (TLDI'07) (Nice, France). ACM Press, New York, NY, USA, 67-78. https://doi.org/10.1145/1190315.1190325

Digital Library

[43]

Robbert Krebbers, Jacques-Henri Jourdan, Ralf Jung, Joseph Tassarotti, Jan-Oliver Kaiser, Amin Timany, Arthur Charguéraud, and Derek Dreyer. 2018. MoSeL: A General, Extensible Modal Framework for Interactive Proofs in Separation Logic. Proc. ACM Program. Lang. 2, ICFP, Article 77 ( July 2018 ), 30 pages. https://doi.org/10.1145/3236772

Digital Library

[44]

Robbert Krebbers, Ralf Jung, Aleš Bizjak, Jacques-Henri Jourdan, Derek Dreyer, and Lars Birkedal. 2017. The Essence of Higher-Order Concurrent Separation Logic. In Proceedings of the 26th European Symposium on Programming Languages and Systems-Volume 10201. Springer-Verlag, Berlin, Heidelberg, 696-723. https://doi.org/10.1007/978-3-662-54434-1_26

Digital Library

[45]

Neelakantan R. Krishnaswami. 2012. Verifying Higher-Order Imperative Programs with Higher-Order Separation Logic. Ph.D. Dissertation. USA. Advisor(s) Aldrich, Jonathan. https://doi.org/10.5555/2519942

Digital Library

[46]

Neelakantan R. Krishnaswami, Jonathan Aldrich, and Lars Birkedal. 2007. Modular verification of the subject-observer pattern via higher-order separation logic. In In Proceedings of Formal Techniques for Java-like Programs (FTfJP).

[47]

Neel R. Krishnaswami, Lars Birkedal, and Jonathan Aldrich. 2010. Verifying Event-Driven Programs Using Ramified Frame Properties. In Proceedings of the 5th ACM SIGPLAN Workshop on Types in Language Design and Implementation (Madrid, Spain) ( TLDI '10). Association for Computing Machinery, New York, NY, USA, 63-76. https://doi.org/10.1145/1708016. 1708025

Digital Library

[48]

Ramana Kumar, Magnus O. Myreen, Michael Norrish, and Scott Owens. 2014. CakeML: A Verified Implementation of ML. In Principles of Programming Languages (POPL). ACM Press, 179-191. https://doi.org/10.1145/2535838.2535841

Digital Library

[49]

Peter Lammich. 2019a. Generating Verified LLVM from Isabelle/HOL. In 10th International Conference on Interactive Theorem Proving, ITP 2019, September 9-12, 2019, Portland, OR, USA (LIPIcs, Vol. 141 ), John Harrison, John O'Leary, and Andrew Tolmach (Eds.). Schloss Dagstuhl-Leibniz-Zentrum für Informatik, 22 : 1-22 : 19. https://doi.org/10.4230/LIPIcs.ITP. 2019.22

[50]

Peter Lammich. 2019b. Refinement to Imperative HOL. Journal of Automated Reasoning (JAR) 62, 4 (April 2019 ), 481-503. https://doi.org/10.1007/s10817-017-9437-1

Digital Library

[51]

Xavier Leroy. 2009. Formal Verification of a Realistic Compiler. Commun. ACM 52, 7 ( July 2009 ), 107-115. https: //doi.org/10.1145/1538788.1538814

Digital Library

[52]

Nicolas Marti, Reynald Afeldt, and Akinori Yonezawa. 2006. Formal Verification of the Heap Manager of an Operating System Using Separation Logic. In Proceedings of the 8th International Conference on Formal Methods and Software Engineering (Macao, China) (ICFEM'06). Springer-Verlag, Berlin, Heidelberg, 400-419. https://doi.org/10.1007/11901433_22

Digital Library

[53]

Andrew McCreight, Zhong Shao, Chunxiao Lin, and Long Li. 2007. A General Framework for Certifying Garbage Collectors and Their Mutators. In Proceedings of the 28th ACM SIGPLAN Conference on Programming Language Design and Implementation (San Diego, California, USA) ( PLDI '07). Association for Computing Machinery, New York, NY, USA, 468-479. https://doi.org/10.1145/1250734.1250788

Digital Library

[54]

Peter Müller, Malte Schwerhof, and Alexander J. Summers. 2016. Viper: A Verification Infrastructure for Permission-Based Reasoning. In Verification, Model Checking, and Abstract Interpretation, Barbara Jobstmann and K. Rustan M. Leino (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 41-62. https://doi.org/10.1007/978-3-662-49122-5_2

Digital Library

[55]

Magnus O Myreen. 2008. Formal verification of machine-code programs. Ph.D. Dissertation.

[56]

Magnus O. Myreen and Michael J. C. Gordon. 2007. Hoare Logic for Realistically Modelled Machine Code. In Proceedings of the 13th International Conference on Tools and Algorithms for the Construction and Analysis of Systems (Braga, Portugal) (TACAS'07). Springer-Verlag, Berlin, Heidelberg, 568-582. https://doi.org/10.1007/978-3-540-71209-1_44

[57]

Glen Mével, Jacques-Henri Jourdan, and François Pottier. 2019. Time credits and time receipts in Iris. In European Symposium on Programming (ESOP) (Lecture Notes in Computer Science, Vol. 11423 ), Luis Caires (Ed.). Springer, 1-27. https: //doi.org/10.1007/978-3-030-17184-1_1

[58]

Aleksandar Nanevski, Greg Morrisett, and Lars Birkedal. 2006. Polymorphism and Separation in Hoare Type Theory. SIGPLAN Not. 41, 9 (Sept. 2006 ), 62-73. https://doi.org/10.1145/1160074.1159812

Digital Library

[59]

Aleksandar Nanevski, Greg Morrisett, and Lars Birkedal. 2008a. Hoare Type Theory, Polymorphism and Separation. J. Funct. Program. 18, 5-6 ( Sept. 2008 ), 865-911. https://doi.org/10.1017/S0956796808006953

Digital Library

[60]

Aleksandar Nanevski, Greg Morrisett, Avraham Shinnar, Paul Govereau, and Lars Birkedal. 2008b. Ynot: Dependent Types for Imperative Programs. SIGPLAN Not. 43, 9 (Sept. 2008 ), 229-240. https://doi.org/10.1145/1411203.1411237

Digital Library

[61]

Zhaozhong Ni and Zhong Shao. 2006. Certified Assembly Programming with Embedded Code Pointers. In Conference Record of the 33rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (Charleston, South Carolina, USA) ( POPL '06). Association for Computing Machinery, New York, NY, USA, 320-333. https://doi.org/10.1145/1111037.1111066

Digital Library

[62]

Zhaozhong Ni, Dachuan Yu, and Zhong Shao. 2007. Using XCAP to Certify Realistic Systems Code: Machine Context Management. In Theorem Proving in Higher Order Logics, Klaus Schneider and Jens Brandt (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 189-206. https://doi.org/10.1007/978-3-540-74591-4_15

[63]

O'Hearn, Reynolds, and Yang. 2001. Local Reasoning about Programs that Alter Data Structures. In CSL: 15th Workshop on Computer Science Logic. LNCS, Springer-Verlag. https://doi.org/10.1007/3-540-44802-0_1

[64]

Peter W. O'Hearn. 2019. Separation logic. Commun. ACM 62, 2 ( 2019 ), 86-95. https://doi.org/10.1145/3211968 The appendix is linked as supplementary material from the ACM digital library.

Digital Library

[65]

Peter W. O'Hearn and David J. Pym. 1999. The Logic of Bunched Implications. The Bulletin of Symbolic Logic 5, 2 ( 1999 ), 215-244. http://www.jstor.org/stable/421090

[66]

Pieter Philippaerts, Jan Tobias Mühlberg, Willem Penninckx, Jan Smans, Bart Jacobs, and Frank Piessens. 2014. Software Verification with VeriFast: Industrial Case Studies. Sci. Comput. Program. 82 (March 2014 ), 77-97. https://doi.org/10. 1016/j.scico. 2013. 01.006

Digital Library

[67]

Benjamin C. Pierce and many contributors. 2016. Software Foundations. https://softwarefoundations.cis.upenn.edu/

[68]

François Pottier. 2008. Hiding local state in direct style: a higher-order anti-frame rule. In IEEE Symposium on Logic In Computer Science (LICS). Pittsburgh, Pennsylvania, 331-340. https://doi.org/10.1109/LICS. 2008.16

Digital Library

[69]

François Pottier. 2017. Verifying a Hash Table and Its Iterators in Higher-Order Separation Logic. In ACM SIGPLAN Conference on Certified Programs and Proofs (CPP) (Paris, France) (CPP 2017 ). Association for Computing Machinery, New York, NY, USA, 3-16. https://doi.org/10.1145/3018610.3018624

Digital Library

[70]

Viorel Preoteasa. 2006. Mechanical Verification of Recursive Procedures Manipulating Pointers Using Separation Logic. In FM 2006: Formal Methods, Jayadev Misra, Tobias Nipkow, and Emil Sekerinski (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 508-523. https://doi.org/10.1007/11813040_34

Digital Library

[71]

Bernhard Reus and Jan Schwinghammer. 2006. Separation Logic for Higher-Order Store. In Computer Science Logic, Zoltán Ésik (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg, 575-590. https://doi.org/10.1007/11874683_38

Digital Library

[72]

John C. Reynolds. 2002. Separation Logic: A Logic for Shared Mutable Data Structures. In Annual IEEE Symposium on Logic in Computer Science (LICS). 55-74. https://doi.org/10.1109/LICS. 2002.1029817

[73]

John C Reynolds. 2006. A short course on separation logic. http://cs.ioc.ee/yik/schools/win2006/reynolds/estslides.pdf

[74]

Adam Sandberg Ericsson, Magnus O. Myreen, and Johannes Åman Pohjola. 2019. A Verified Generational Garbage Collector for CakeML. Journal of Automated Reasoning (JAR) 63 ( 2019 ). https://doi.org/10.1007/s10817-018-9487-z

Digital Library

[75]

Jan Schwinghammer, Lars Birkedal, Bernhard Reus, and Hongseok Yang. 2009. Nested Hoare Triples and Frame Rules for Higher-Order Store. In Computer Science Logic, Erich Grädel and Reinhard Kahle (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 440-454. https://doi.org/10.1007/978-3-642-04027-6_32

[76]

Jan Schwinghammer, Hongseok Yang, Lars Birkedal, François Pottier, and Bernhard Reus. 2010. A Semantic Foundation for Hidden State. In Foundations of Software Science and Computational Structures, Luke Ong (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg, 2-17. https://doi.org/10.1007/978-3-642-12032-9_2

Digital Library

[77]

Kasper Svendsen, Lars Birkedal, and Matthew Parkinson. 2010. Verifying Generics and Delegates. In ECOOP 2010-Object-Oriented Programming, Theo D'Hondt (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg, 175-199. https: //doi.org/10.1007/978-3-642-14107-2_9

[78]

Joseph Tassarotti, Ralf Jung, and Robert Harper. 2017. A Higher-Order Logic for Concurrent Termination-Preserving Refinement. In Programming Languages and Systems, Hongseok Yang (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg, 909-936. https://doi.org/10.1007/978-3-662-54434-1_34

Digital Library

[79]

Harvey Tuch, Gerwin Klein, and Michael Norrish. 2007. Types, Bytes, and Separation Logic. SIGPLAN Not. 42, 1 (Jan. 2007 ), 97-108. https://doi.org/10.1145/1190215.1190234

Digital Library

[80]

Thomas Tuerk. 2010. Local Reasoning about While-Loops. In In International Conference on Verified Software: Theories, Tools and Experiments.

[81]

Thomas Tuerk. 2011. A separation logic framework for HOL. Technical Report UCAM-CL-TR-799. University of Cambridge, Computer Laboratory. https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-799.pdf

[82]

Viktor Vafeiadis and Matthew Parkinson. 2007. A Marriage of Rely/Guarantee and Separation Logic. In CONCUR 2007-Concurrency Theory, Luís Caires and Vasco T. Vasconcelos (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 256-271. https://doi.org/10.1007/978-3-540-74407-8_18

[83]

Carsten Varming and Lars Birkedal. 2008. Higher-Order Separation Logic in Isabelle/HOLCF. Electronic Notes in Theoretical Computer Science 218 ( 2008 ), 371-389. https://doi.org/10.1016/j.entcs. 2008. 10. 022 Proceedings of the 24th Conference on the Mathematical Foundations of Programming Semantics (MFPS XXIV).

Digital Library

[84]

Wei Wang, Zhong Shao, Xinyu Jiang, and Yu Guo. 2011. A Simple Model for Certifying Assembly Programs with FirstClass Function Pointers. In 5th IEEE International Symposium on Theoretical Aspects of Software Engineering, TASE 2011, Xi'an, China, 29-31 August 2011, Zhenhua Duan and C.-H. Luke Ong (Eds.). IEEE Computer Society, 125-132. https://doi.org/10.1109/TASE. 2011.16

Digital Library

[85]

Tjark Weber. 2004. Towards Mechanized Program Verification with Separation Logic. In Computer Science Logic, Jerzy Marcinkowski and Andrzej Tarlecki (Eds.). Springer Berlin Heidelberg, Berlin, Heidelberg, 250-264. https://doi.org/10. 1007/978-3-540-30124-0_21

[86]

Fengwei Xu, Ming Fu, Xinyu Feng, Xiaoran Zhang, Hui Zhang, and Zhaohui Li. 2016. A practical verification framework for preemptive OS kernels. In International Conference on Computer Aided Verification, Swarat Chaudhuri and Azadeh Farzan (Eds.). Springer, Springer International Publishing, Cham, 59-79. https://doi.org/10.1007/978-3-319-41540-6_4

[87]

Dachuan Yu, Nadeem A. Hamid, and Zhong Shao. 2003. Building Certified Libraries for PCC: Dynamic Storage Allocation. In Programming Languages and Systems, Pierpaolo Degano (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg, 363-379. https://doi.org/10.1007/3-540-36575-3_25

[88]

Dachuan Yu, Nadeem A. Hamid, and Zhong Shao. 2004. Building Certified Libraries for PCC: Dynamic Storage Allocation. Science of Computer Programming 50, 1-3 ( 2004 ), 101-127. https://doi.org/10.1007/3-540-36575-3_25

Cited By

Zhang BJin ZWang HCao Y(2024)Formal Verification of Data Modifications in Cloud Block Storage Based on Separation LogicChinese Journal of Electronics10.23919/cje.2022.00.11633:1(112-127)Online publication date: Jan-2024
https://doi.org/10.23919/cje.2022.00.116
Gladshtein VZhao QAhrens WAmarasinghe SSergey I(2024)Mechanised Hypersafety Proofs about Structured DataProceedings of the ACM on Programming Languages10.1145/36564038:PLDI(647-670)Online publication date: 20-Jun-2024
https://dl.acm.org/doi/10.1145/3656403
Zhao QPîrlea GAng ZMathur USergey ITimany ATraytel DPientka BBlazy S(2024)Rooting for Efficiency: Mechanised Reasoning about Array-Based Trees in Separation LogicProceedings of the 13th ACM SIGPLAN International Conference on Certified Programs and Proofs10.1145/3636501.3636944(45-59)Online publication date: 9-Jan-2024
https://dl.acm.org/doi/10.1145/3636501.3636944
Show More Cited By

Index Terms

Separation logic for sequential programs (functional pearl)
1. Theory of computation
  1. Logic
    1. Logic and verification
    2. Separation logic

Recommendations

Interactive proofs in higher-order concurrent separation logic
POPL '17: Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages

When using a proof assistant to reason in an embedded logic -- like separation logic -- one cannot benefit from the proof contexts and basic tactics of the proof assistant. This results in proofs that are at a too low level of abstraction because they ...
Interactive proofs in higher-order concurrent separation logic
POPL '17

When using a proof assistant to reason in an embedded logic -- like separation logic -- one cannot benefit from the proof contexts and basic tactics of the proof assistant. This results in proofs that are at a too low level of abstraction because they ...
Tactics for Proving Separation Logic Assertion in Coq Proof Assistant
ICVISP 2019: Proceedings of the 3rd International Conference on Vision, Image and Signal Processing

The verification of the correctness of large programs, particularly operating systems is an unmanageable but important endeavor. we are interested in verifying C programs with formal methods, the logic is separation logic, a Hoare-style program logic. ...

Comments

Information & Contributors

Information

Published In

cover image Proceedings of the ACM on Programming Languages

Proceedings of the ACM on Programming Languages Volume 4, Issue ICFP

August 2020

1070 pages

EISSN:2475-1421

DOI:10.1145/3415018

Issue’s Table of Contents

Copyright © 2020 Owner/Author.

This work is licensed under a Creative Commons Attribution International 4.0 License.

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 03 August 2020

Published in PACMPL Volume 4, Issue ICFP

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Funding Sources

French National Research Organization (ANR)

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

19
Total Citations
View Citations
1,178
Total Downloads

Downloads (Last 12 months)302
Downloads (Last 6 weeks)45

Reflects downloads up to 09 Feb 2025

Other Metrics

View Author Metrics

Citations

Cited By

Zhang BJin ZWang HCao Y(2024)Formal Verification of Data Modifications in Cloud Block Storage Based on Separation LogicChinese Journal of Electronics10.23919/cje.2022.00.11633:1(112-127)Online publication date: Jan-2024
https://doi.org/10.23919/cje.2022.00.116
Gladshtein VZhao QAhrens WAmarasinghe SSergey I(2024)Mechanised Hypersafety Proofs about Structured DataProceedings of the ACM on Programming Languages10.1145/36564038:PLDI(647-670)Online publication date: 20-Jun-2024
https://dl.acm.org/doi/10.1145/3656403
Zhao QPîrlea GAng ZMathur USergey ITimany ATraytel DPientka BBlazy S(2024)Rooting for Efficiency: Mechanised Reasoning about Array-Based Trees in Separation LogicProceedings of the 13th ACM SIGPLAN International Conference on Certified Programs and Proofs10.1145/3636501.3636944(45-59)Online publication date: 9-Jan-2024
https://dl.acm.org/doi/10.1145/3636501.3636944
Jacobs JHinrichsen JKrebbers R(2024)Deadlock-Free Separation Logic: Linearity Yields Progress for Dependent Higher-Order Message PassingProceedings of the ACM on Programming Languages10.1145/36328898:POPL(1385-1417)Online publication date: 5-Jan-2024
https://dl.acm.org/doi/10.1145/3632889
Soares TChirica IPereira M(2024)Static and Dynamic Verification of OCaml Programs: The Gospel EcosystemLeveraging Applications of Formal Methods, Verification and Validation. Specification and Verification10.1007/978-3-031-75380-0_14(247-265)Online publication date: 27-Oct-2024
https://dl.acm.org/doi/10.1007/978-3-031-75380-0_14
Pereira M(2024)Practical Deductive Verification of OCaml ProgramsFormal Methods10.1007/978-3-031-71177-0_29(518-542)Online publication date: 9-Sep-2024
https://dl.acm.org/doi/10.1007/978-3-031-71177-0_29
Gopinathan KKeoliya MSergey I(2023)Mostly Automated Proof Repair for Verified LibrariesProceedings of the ACM on Programming Languages10.1145/35912217:PLDI(25-49)Online publication date: 6-Jun-2023
https://dl.acm.org/doi/10.1145/3591221
Charguéraud AChlipala AErbsen AGruetter S(2023)Omnisemantics: Smooth Handling of NondeterminismACM Transactions on Programming Languages and Systems10.1145/357983445:1(1-43)Online publication date: 8-Mar-2023
https://dl.acm.org/doi/10.1145/3579834
Huyghebaert SKeuchel SDe Roover CDevriese DMeng WJensen CCremers CKirda E(2023)Formalizing, Verifying and Applying ISA Security Guarantees as Universal ContractsProceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security10.1145/3576915.3616602(2083-2097)Online publication date: 15-Nov-2023
https://dl.acm.org/doi/10.1145/3576915.3616602
Song YCho MLee DHur CSammler MDreyer D(2023)Conditional Contextual RefinementProceedings of the ACM on Programming Languages10.1145/35712327:POPL(1121-1151)Online publication date: 11-Jan-2023
https://dl.acm.org/doi/10.1145/3571232
Show More Cited By

View Options

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Article

Figures

Tables

Media

View Issue’s Table of Contents