141,026 research outputs found
High-level Programming via Generalized Planning and LTL Synthesis
We look at program synthesis where the aim is to automatically synthesize a controller that operates on data structures and from which a concrete program can be easily derived. We do not aim at a fully-automatic process or tool that produces a program meeting a given specification of the programās behaviour. Rather, we aim at the design of a clear and well- founded approach for supporting programmers at the design and implementation phases. Concretely, we first show that a program synthesis task can be modeled as a generalized planning problem. This is done at an abstraction level where the involved data structures are seen as black-boxes that can be interfaced with actions and observations, the first corresponding to the operations and the second to the queries provided by the data structure. The abstraction level is high enough to capture intuitive and common assumptions as well as general and simple strategies used by programmers, and yet it contains sufficient structure to support the automated generation of concrete solutions (in the form of controllers). From such controllers and the use of standard data structures, an actual program in a general language like C++ or Python can be easily obtained. Then, we discuss how the resulting generalized planning problem can be reduced to an LTL synthesis problem, thus making available any LTL synthesis engine for obtaining the controllers. We illustrate the effectiveness of the approach on a series of examples
Code Building Genetic Programming
In recent years the field of genetic programming has made significant
advances towards automatic programming. Research and development of
contemporary program synthesis methods, such as PushGP and Grammar Guided
Genetic Programming, can produce programs that solve problems typically
assigned in introductory academic settings. These problems focus on a narrow,
predetermined set of simple data structures, basic control flow patterns, and
primitive, non-overlapping data types (without, for example, inheritance or
composite types). Few, if any, genetic programming methods for program
synthesis have convincingly demonstrated the capability of synthesizing
programs that use arbitrary data types, data structures, and specifications
that are drawn from existing codebases. In this paper, we introduce Code
Building Genetic Programming (CBGP) as a framework within which this can be
done, by leveraging programming language features such as reflection and
first-class specifications. CBGP produces a computational graph that can be
executed or translated into source code of a host language. To demonstrate the
novel capabilities of CBGP, we present results on new benchmarks that use
non-primitive, polymorphic data types as well as some standard program
synthesis benchmarks.Comment: Proceedings of the 2020 Genetic and Evolutionary Computation
Conference, Genetic Programming Trac
Analysing Parallel Complexity of Term Rewriting
We revisit parallel-innermost term rewriting as a model of parallel
computation on inductive data structures and provide a corresponding notion of
runtime complexity parametric in the size of the start term. We propose
automatic techniques to derive both upper and lower bounds on parallel
complexity of rewriting that enable a direct reuse of existing techniques for
sequential complexity. The applicability and the precision of the method are
demonstrated by the relatively light effort in extending the program analysis
tool AProVE and by experiments on numerous benchmarks from the literature.Comment: Extended authors' accepted manuscript for a paper accepted for
publication in the Proceedings of the 32nd International Symposium on
Logic-based Program Synthesis and Transformation (LOPSTR 2022). 27 page
Multi-Intent Detection in User Provided Annotations for Programming by Examples Systems
In mapping enterprise applications, data mapping remains a fundamental part
of integration development, but its time consuming. An increasing number of
applications lack naming standards, and nested field structures further add
complexity for the integration developers. Once the mapping is done, data
transformation is the next challenge for the users since each application
expects data to be in a certain format. Also, while building integration flow,
developers need to understand the format of the source and target data field
and come up with transformation program that can change data from source to
target format. The problem of automatic generation of a transformation program
through program synthesis paradigm from some specifications has been studied
since the early days of Artificial Intelligence (AI). Programming by Example
(PBE) is one such kind of technique that targets automatic inferencing of a
computer program to accomplish a format or string conversion task from
user-provided input and output samples. To learn the correct intent, a diverse
set of samples from the user is required. However, there is a possibility that
the user fails to provide a diverse set of samples. This can lead to multiple
intents or ambiguity in the input and output samples. Hence, PBE systems can
get confused in generating the correct intent program. In this paper, we
propose a deep neural network based ambiguity prediction model, which analyzes
the input-output strings and maps them to a different set of properties
responsible for multiple intent. Users can analyze these properties and
accordingly can provide new samples or modify existing samples which can help
in building a better PBE system for mapping enterprise applications
Invariant Synthesis for Incomplete Verification Engines
We propose a framework for synthesizing inductive invariants for incomplete
verification engines, which soundly reduce logical problems in undecidable
theories to decidable theories. Our framework is based on the counter-example
guided inductive synthesis principle (CEGIS) and allows verification engines to
communicate non-provability information to guide invariant synthesis. We show
precisely how the verification engine can compute such non-provability
information and how to build effective learning algorithms when invariants are
expressed as Boolean combinations of a fixed set of predicates. Moreover, we
evaluate our framework in two verification settings, one in which verification
engines need to handle quantified formulas and one in which verification
engines have to reason about heap properties expressed in an expressive but
undecidable separation logic. Our experiments show that our invariant synthesis
framework based on non-provability information can both effectively synthesize
inductive invariants and adequately strengthen contracts across a large suite
of programs
Recommended from our members
General Program Synthesis from Examples Using Genetic Programming with Parent Selection Based on Random Lexicographic Orderings of Test Cases
Software developers routinely create tests before writing code, to ensure that their programs fulfill their requirements. Instead of having human programmers write the code to meet these tests, automatic program synthesis systems can create programs to meet specifications without human intervention, only requiring examples of desired behavior. In the long-term, we envision using genetic programming to synthesize large pieces of software. This dissertation takes steps toward this goal by investigating the ability of genetic programming to solve introductory computer science programming problems.
We present a suite of 29 benchmark problems intended to test general program synthesis systems, which we systematically selected from sources of introductory computer science programming problems. This suite is suitable for experiments with any program synthesis system driven by input/output examples. Unlike existing benchmarks that concentrate on constrained problem domains such as list manipulation, symbolic regression, or boolean functions, this suite contains general programming problems that require a range of programming constructs, such as multiple data types and data structures, control flow statements, and I/O. The problems encompass a range of difficulties and requirements as necessary to thoroughly assess the capabilities of a program synthesis system. Besides describing the specifications for each problem, we make recommendations for experimental protocols and statistical methods to use with the problems.
This dissertation\u27s second contribution is an investigation of behavior-based parent selection in genetic programming, concentrating on a new method called lexicase selection. Most parent selection techniques aggregate errors from test cases to compute a single scalar fitness value; lexicase selection instead treats test cases separately, never comparing error values of different test cases. This property allows it to select parents that specialize on some test cases even if they perform poorly on others. We compare lexicase selection to other parent selection techniques on our benchmark suite, showing better performance for lexicase selection. After observing that lexicase selection increases exploration of the search space while also increasing exploitation of promising programs, we conduct a range of experiments to identify which characteristics of lexicase selection influence its utility
Recursive Program Optimization Through Inductive Synthesis Proof Transformation
The research described in this paper involved developing transformation techniques which increase the efficiency of the noriginal program, the source, by transforming its synthesis proof into one, the target, which yields a computationally more efficient algorithm. We describe a working proof transformation system which, by exploiting the duality between mathematical induction and recursion, employs the novel strategy of optimizing recursive programs by transforming inductive proofs. We compare and contrast this approach with the more traditional approaches to program transformation, and highlight the benefits of proof transformation with regards to search, correctness, automatability and generality
Automatic Software Repair: a Bibliography
This article presents a survey on automatic software repair. Automatic
software repair consists of automatically finding a solution to software bugs
without human intervention. This article considers all kinds of repairs. First,
it discusses behavioral repair where test suites, contracts, models, and
crashing inputs are taken as oracle. Second, it discusses state repair, also
known as runtime repair or runtime recovery, with techniques such as checkpoint
and restart, reconfiguration, and invariant restoration. The uniqueness of this
article is that it spans the research communities that contribute to this body
of knowledge: software engineering, dependability, operating systems,
programming languages, and security. It provides a novel and structured
overview of the diversity of bug oracles and repair operators used in the
literature
- ā¦