research-article

Data-driven inference of representation invariants

Authors:

Anders Miltner,

Todd Millstein,

David WalkerAuthors Info & Claims

PLDI 2020: Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation

Pages 1 - 15

https://doi.org/10.1145/3385412.3385967

Published: 11 June 2020 Publication History

Abstract

A representation invariant is a property that holds of all values of abstract type produced by a module. Representation invariants play important roles in software engineering and program verification. In this paper, we develop a counterexample-driven algorithm for inferring a representation invariant that is sufficient to imply a desired specification for a module. The key novelty is a type-directed notion of visible inductiveness, which ensures that the algorithm makes progress toward its goal as it alternates between weakening and strengthening candidate invariants. The algorithm is parameterized by an example-based synthesis engine and a verifier, and we prove that it is sound and complete for first-order modules over finite types, assuming that the synthesizer and verifier are as well. We implement these ideas in a tool called Hanoi, which synthesizes representation invariants for recursive data types. Hanoi not only handles invariants for first-order code, but higher-order code as well. In its back end, Hanoi uses an enumerative synthesizer called Myth and an enumerative testing tool as a verifier. Because Hanoi uses testing for verification, it is not sound, though our empirical evaluation shows that it is successful on the benchmarks we investigated.

References

[1]

Andrew Appel. 2018. Software Foundations Volume 3: Verified Functional Algorithms. https://softwarefoundations.cis.upenn.edu/vfacurrent/index.html

[2]

Haniel Barbosa, Andrew Reynolds, Daniel Larraz, and Cesare Tinelli. 2019. Extending Enumerative Function Synthesis via SMT-Driven Classification. In 2019 Formal Methods in Computer Aided Design, FMCAD. IEEE, 212–220.

[3]

C. Boyapati, S. Khurshid, and D. Marinov. 2002. Korat: Automated testing based on Java predicates. In Proceedings of the International Symposium on Software Testing and Analysis (ISSTA’02). ACM, Roma, Italy, 123–133.

[4]

Aaron R. Bradley. [n.d.]. SAT-Based Model Checking without Unrolling. In Verification, Model Checking, and Abstract Interpretation - 12th International Conference, VMCAI 2011, Austin, TX, USA, January 23-25, 2011. Proceedings (Lecture Notes in Computer Science). Springer, 70–87.

[5]

Adrien Champion, Tomoya Chiba, Naoki Kobayashi, and Ryosuke Sato. 2018. ICE-Based Refinement Type Discovery for Higher-Order Functional Programs. In Tools and Algorithms for the Construction and Analysis of Systems - 24th International Conference, TACAS (Lecture Notes in Computer Science), Vol. 10805. Springer, 365–384.

[6]

Koen Claessen and John Hughes. 2000. QuickCheck: a lightweight tool for random testing of Haskell programs. In Proceedings of the ACM Sigplan International Conference on Functional Programming (ICFP-00) (ACM Sigplan Notices), Vol. 35.9. ACM Press, N.Y., 268–279.

Digital Library

[7]

P. Ezudheen, Daniel Neider, Deepak D’Souza, Pranav Garg, and P. Madhusudan. 2018. Horn-ICE Learning for Synthesizing Invariants and Contracts. PACMPL 2, OOPSLA (2018), 131:1–131:25.

Digital Library

[8]

Grigory Fedyukovich, Samuel J. Kaufman, and Rastislav Bodík. 2017. Sampling Invariants from Frequency Distributions. In 2017 Formal Methods in Computer Aided Design, FMCAD. IEEE, 100–107.

[9]

Robert Bruce Findler and Matthias Felleisen. 2002. Contracts for higher-order functions. In Proceedings of ACM SIGPLAN International Conference on Functional Programming. ACM, New York, NY, 48–59.

Digital Library

[10]

Pranav Garg, Daniel Neider, P. Madhusudan, and Dan Roth. 2016. Learning Invariants using Decision Trees and Implication Counterexamples. In Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL. ACM, 499–512.

Digital Library

[11]

Hossein Hojjat and Philipp Rümmer. 2018. The ELDARICA Horn Solver. In 2018 Formal Methods in Computer Aided Design, FMCAD. IEEE, 1–7.

[12]

Ming Kawaguchi, Patrick Rondon, and Ranjit Jhala. 2009. Typebased Data Structure Verification. In Proceedings of the 30th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’09). ACM, New York, NY, USA, 304–315.

Digital Library

[13]

Anvesh Komuravelli, Arie Gurfinkel, and Sagar Chaki. 2016. SMTBased Model Checking for Recursive Programs. Formal Methods in System Design 48, 3 (2016), 175–205. 016-0249-4

Digital Library

[14]

Ton Chanh Le, Guolong Zheng, and ThanhVu Nguyen. 2019. SLING: Using Dynamic Analysis to Infer Program Invariants in Separation Logic. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI, Kathryn S. McKinley and Kathleen Fisher (Eds.). ACM, 788–801. 3314221.3314634

Digital Library

[15]

Muhammad Zubair Malik, Aman Pervaiz, and Sarfraz Khurshid. 2007. Generating Representation Invariants of Structurally Complex Data. In Tools and Algorithms for the Construction and Analysis of Systems, 13th International Conference, TACAS (Lecture Notes in Computer Science), Vol. 4424. Springer, 34–49. 1_5

[16]

Bertrand Meyer. 1997. Design by Contract: Making Object-Oriented Programs that Work. In TOOLS (25). IEEE Computer Society, 360. https://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=5604

[17]

Anders Miltner, Saswat Padhi, Todd Millstein, and David Walker. 2020.

[18]

Data-Driven Inference of Representation Invariants. arXiv: cs.PL/2003.12106

[19]

Daniel Neider, Pranav Garg, P. Madhusudan, Shambwaditya Saha, and Daejun Park. 2018. Invariant Synthesis for Incomplete Verification Engines. In Tools and Algorithms for the Construction and Analysis of Systems - 24th International Conference, TACAS (Lecture Notes in Computer Science), Vol. 10805. Springer, 232–250. 1007/978-3-319-89960-2_13

[20]

ThanhVu Nguyen, Timos Antonopoulos, Andrew Ruef, and Michael Hicks. 2017. Counterexample-Guided Approach to Finding Numerical Invariants. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering, ESEC/FSE. ACM, 605–615. 1145/3106237.3106281

Digital Library

[21]

Peter-Michael Osera and Steve Zdancewic. 2015. Type-and-Example-Directed Program Synthesis. In Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation, POPL. ACM, 619–630.

Digital Library

[22]

Saswat Padhi, Rahul Sharma, and Todd D. Millstein. 2016. Data-Driven Precondition Inference with Learned Features. In Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI. ACM, 42–56.

Digital Library

[23]

2908099

[24]

Benjamin C. Pierce. 2002. Types and Programming Languages. MIT Press.

Digital Library

[25]

https://www.cis.upenn.edu/~bcpierce/tapl/

[26]

John C. Reynolds. 1983. Types, Abstraction and Parametric Polymorphism. In Information Processing 83, Proceedings of the IFIP 9th World Computer Congress, Paris, France, September 19-23, 1983. 513–523.

[27]

Mooly Sagiv, Thomas Reps, and Reinhard Wilhelm. 1999. Parametric Shape Analysis via 3-valued Logic. In Proceedings of the 26th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’99). ACM, New York, NY, USA, 105–118. 1145/292540.292552

Digital Library

[28]

Rahul Sharma and Alex Aiken. 2016. From Invariant Checking to Invariant Inference using Randomized Search. Formal Methods in System Design 48, 3 (2016), 235–256. 016-0248-5

Digital Library

[29]

Xujie Si, Hanjun Dai, Mukund Raghothaman, Mayur Naik, and Le Song. 2018. Learning Loop Invariants for Program Verification. In Data-Driven Inference of Representation Invariants PLDI ’20, June 15–20, 2020, London, UK Advances in Neural Information Processing Systems 31: Annual Conference on Neural Information Processing Systems 2018, NeurIPS. 7762– 7773. https://papers.nips.cc/paper/8001-learning-loop-invariants-forprogram-verification

[30]

Lau Skorstengaard. 2015. An Introduction to Logical Relations. https://www.cs.uoregon.edu/research/summerschool/ summer16/notes/AhmedLR.pdf Notes based on lectures by Amal Ahmed at the Oregon Programming Languages Summer School.

[31]

Armando Solar-Lezama. 2013. Program Sketching. STTT 15, 5-6 (2013), 475–495.

Digital Library

[32]

Philippe Suter, Ali Sinan Köksal, and Viktor Kuncak. 2011. Satisfiability Modulo Recursive Programs. In Static Analysis - 18th International Symposium, SAS (Lecture Notes in Computer Science), Vol. 6887. Springer, 298–315.

[33]

The Coq Development Team. 2019. The Coq Proof Assistant, version 8.10.0.

Cited By

Zhou ZYe QDelaware BJagannathan S(2024)A HAT Trick: Automatically Verifying Representation Invariants using Symbolic Finite AutomataProceedings of the ACM on Programming Languages10.1145/36564338:PLDI(1387-1411)Online publication date: 20-Jun-2024
https://dl.acm.org/doi/10.1145/3656433
Pailoor SWang YDillig I(2024)Semantic Code Refactoring for Abstract Data TypesProceedings of the ACM on Programming Languages10.1145/36328708:POPL(816-847)Online publication date: 5-Jan-2024
https://dl.acm.org/doi/10.1145/3632870
Boockmann JLüttgen G(2024)On the Hunt for Invalid Objects: Exploring the Object State Space with Program Mutants2024 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)10.1109/SANER60148.2024.00078(711-716)Online publication date: 12-Mar-2024
https://doi.org/10.1109/SANER60148.2024.00078
Show More Cited By

Index Terms

Data-driven inference of representation invariants
1. Software and its engineering
  1. Software creation and management
    1. Software verification and validation
2. Theory of computation
  1. Semantics and reasoning
    1. Program reasoning
      1. Invariants

Recommendations

Decidability of conversion for type theory in type theory

Type theory should be able to handle its own meta-theory, both to justify its foundational claims and to obtain a verified implementation. At the core of a type checker for intensional type theory lies an algorithm to check equality of types, or in other ...
State-dependent representation independence
POPL '09

Mitchell's notion of representation independence is a particularly useful application of Reynolds' relational parametricity -- two different implementations of an abstract data type can be shown contextually equivalent so long as there exists a relation ...
Data-driven lemma synthesis for interactive proofs

Interactive proofs of theorems often require auxiliary helper lemmas to prove the desired theorem. Existing approaches for automatically synthesizing helper lemmas fall into two broad categories. Some approaches are goal-directed, producing lemmas ...

Comments

Information & Contributors

Information

Published In

cover image ACM Conferences

PLDI 2020: Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation

June 2020

1174 pages

ISBN:9781450376136

DOI:10.1145/3385412

General Chair:
Alastair F. Donaldson
Imperial College London, UK
,
Program Chair:
Emina Torlak
University of Washington, USA

Copyright © 2020 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected].

Sponsors

SIGPLAN: ACM Special Interest Group on Programming Languages

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 11 June 2020

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Badges

Author Tags

Qualifiers

Research-article

Funding Sources

National Science Foundation

Conference

PLDI '20

Sponsor:

SIGPLAN

PLDI '20: 41st ACM SIGPLAN International Conference on Programming Language Design and Implementation

June 15 - 20, 2020

London, UK

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

16
Total Citations
View Citations
572
Total Downloads

Downloads (Last 12 months)61
Downloads (Last 6 weeks)8

Reflects downloads up to 16 Nov 2024

Other Metrics

View Author Metrics

Citations

Cited By

Zhou ZYe QDelaware BJagannathan S(2024)A HAT Trick: Automatically Verifying Representation Invariants using Symbolic Finite AutomataProceedings of the ACM on Programming Languages10.1145/36564338:PLDI(1387-1411)Online publication date: 20-Jun-2024
https://dl.acm.org/doi/10.1145/3656433
Pailoor SWang YDillig I(2024)Semantic Code Refactoring for Abstract Data TypesProceedings of the ACM on Programming Languages10.1145/36328708:POPL(816-847)Online publication date: 5-Jan-2024
https://dl.acm.org/doi/10.1145/3632870
Boockmann JLüttgen G(2024)On the Hunt for Invalid Objects: Exploring the Object State Space with Program Mutants2024 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)10.1109/SANER60148.2024.00078(711-716)Online publication date: 12-Mar-2024
https://doi.org/10.1109/SANER60148.2024.00078
Miltner AWang ZChaudhuri SDillig I(2024)Relational Synthesis of Recursive Programs via Constraint Annotated Tree AutomataComputer Aided Verification10.1007/978-3-031-65633-0_3(41-63)Online publication date: 24-Jul-2024
https://dl.acm.org/doi/10.1007/978-3-031-65633-0_3
Johnson KReynolds AReps TD’Antoni L(2024)The SemGuS ToolkitComputer Aided Verification10.1007/978-3-031-65633-0_2(27-40)Online publication date: 24-Jul-2024
https://dl.acm.org/doi/10.1007/978-3-031-65633-0_2
Boockmann JLüttgen G(2024)Comprehending Object State via Dynamic Class Invariant LearningFundamental Approaches to Software Engineering10.1007/978-3-031-57259-3_7(143-164)Online publication date: 6-Apr-2024
https://dl.acm.org/doi/10.1007/978-3-031-57259-3_7
Park KD'Antoni LReps T(2023)Synthesizing SpecificationsProceedings of the ACM on Programming Languages10.1145/36228617:OOPSLA2(1787-1816)Online publication date: 16-Oct-2023
https://dl.acm.org/doi/10.1145/3622861
Krogmeier PMadhusudan P(2023)Languages with Decidable Learning: A Meta-theoremProceedings of the ACM on Programming Languages10.1145/35860327:OOPSLA1(143-171)Online publication date: 6-Apr-2023
https://dl.acm.org/doi/10.1145/3586032
Cirisci BEnea CFarzan AMutluergil S(2023)A Pragmatic Approach to Stateful Partial Order ReductionVerification, Model Checking, and Abstract Interpretation10.1007/978-3-031-24950-1_7(129-154)Online publication date: 16-Jan-2023
https://dl.acm.org/doi/10.1007/978-3-031-24950-1_7
Kalita PMuduli SD’Antoni LReps TRoy S(2022)Synthesizing abstract transformersProceedings of the ACM on Programming Languages10.1145/35633346:OOPSLA2(1291-1319)Online publication date: 31-Oct-2022
https://dl.acm.org/doi/10.1145/3563334
Show More Cited By

View Options

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 Publication

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Media

Figures

Other

Tables

View Table of Contents