Graph-Based Proof Counting and Enumeration with Applications for Program Fragment Synthesis

Wells, J. B.; Yakobowski, Boris

doi:10.1007/11506676_17

Cited by 16 publications

(13 citation statements)

References 11 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The drawback of this approach is the lack of a mechanism that would automatically enumerate all the proofs. By representing proofs using graphs, the problem of their enumeration was shown to be theoretically solvable [29], but there is a large gap between a theoretical result and an effective tool. Furthermore, InSynth can not only enumerate terms but also rank them and return a desired number of best-ranked ones.…”

Section: Related Workmentioning

confidence: 99%

Complete completion using types and weights

Gvero

Kunčak

Kuraj

et al. 2013

Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation

118

View full text Add to dashboard Cite

Developing modern software typically involves composing functionality from existing libraries. This task is difficult because libraries may expose many methods to the developer. To help developers in such scenarios, we present a technique that synthesizes and suggests valid expressions of a given type at a given program point. As the basis of our technique we use type inhabitation for lambda calculus terms in long normal form. We introduce a succinct representation for type judgements that merges types into equivalence classes to reduce the search space, then reconstructs any desired number of solutions on demand. Furthermore, we introduce a method to rank solutions based on weights derived from a corpus of code. We implemented the algorithm and deployed it as a plugin for the Eclipse IDE for Scala. We show that the techniques we incorporated greatly increase the effectiveness of the approach. Our evaluation benchmarks are code examples from programming practice; we make them available for future comparisons.

show abstract

Section: Related Workmentioning

confidence: 99%

Complete completion using types and weights

Gvero

Kunčak

Kuraj

et al. 2013

Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation

118

View full text Add to dashboard Cite

show abstract

“…This work is partly inspired by (and improves upon) boundedexhaustive enumeration applied for generation of well-typed terms in the domain of program synthesis [22,30,32,49,50]. A comparison and analysis of insufficiency of previously employed techniques can be found in [32].…”

Section: Related Workmentioning

confidence: 99%

“…This work enriches and completes the combinator framework, generalizes the application of pairing functions for different enumeration strategies, and introduces features that go beyond exhaustive enumeration. Enumerators in SciFe follow the common approach for designing a framework with combinators often adopted not just in testing tools [10], but also in tools for tasks such as term generation [17,49,50], and serialization [34]. Overviews of various techniques for generation of test inputs, particularly those for bounded exhaustive testing, can be found in [19,44,45,48].…”

Section: Related Workmentioning

confidence: 99%

Programming with enumerable sets of structures

Kuraj

Kunčak

Jackson

2015

Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applicatio

View full text Add to dashboard Cite

We present an efficient, modular, and feature-rich framework for automated generation and validation of complex structures, suitable for tasks that explore a large space of structured values. Our framework is capable of exhaustive, incremental, parallel, and memoized enumeration from not only finite but also infinite domains, while providing fine-grained control over the process. Furthermore, the framework efficiently supports the inverse of enumeration (checking whether a structure can be generated and fast-forwarding to this structure to continue the enumeration) and lazy enumeration (achieving exhaustive testing without generating all structures). The foundation of efficient enumeration lies in both direct access to encoded structures, achieved with well-known and new pairing functions, and dependent enumeration, which embeds constraints into the enumeration to avoid backtracking. Our framework defines an algebra of enumerators, with combinators for their composition that preserve exhaustiveness and efficiency. We have implemented our framework as a domain-specific language in Scala. Our experiments demonstrate better performance and shorter specifications by up to a few orders of magnitude compared to existing approaches.

show abstract

“…Our approach is related to adaptation synthesis via proof counting [8,9], where semantic types are combined with proof search in a specialized proof system. In particular, we follow [8,9] in using semantic specifications at the interface level.…”

Section: Related Workmentioning

confidence: 99%

“…Following [8,9], a level of semantic types is introduced to specify component interfaces and synthesis goals so as to direct synthesis by means of semantic concepts. Semantic types are not necessarily checked against component implementations (this is regarded as an orthogonal issue).…”

Section: Introductionmentioning

confidence: 99%

Staged Composition Synthesis

Düdder

Martens

Rehof

2014

Programming Languages and Systems

View full text Add to dashboard Cite

Abstract.A framework for composition synthesis is provided in which metalanguage combinators are supported and the execution of synthesized programs can be staged into composition-time code generation (stage 1) and run-time execution (stage 2). By extending composition synthesis to encompass both object language (L1) and metalanguage (L2) combinators, composition synthesis becomes a powerful and flexible framework for the generation of L1-program compositions. A system of modal intersection types is introduced into a combinatory composition language to control the distinction between L1-and L2-combinators at the type level, thereby exposing the language distinction to composition synthesis. We provide a theory of correctness of the framework which ensures that generated compositions of component implementations are well typed and that their execution can be staged such that all metalanguage combinators can be computed away completely at stage 1, leaving only well typed L1-code for execution at stage 2. Our framework has been implemented, and we report on experiments.

show abstract

Graph-Based Proof Counting and Enumeration with Applications for Program Fragment Synthesis

Cited by 16 publications

References 11 publications

Complete completion using types and weights

Complete completion using types and weights

Programming with enumerable sets of structures

Staged Composition Synthesis

Contact Info

Product

Resources

About