Program Synthesis Research Articles

Automated transpilation of imperative to functional code using neural-guided program synthesis

While many mainstream languages such as Java, Python, and C# increasingly incorporate functional APIs to simplify programming and improve parallelization/performance, there are no effective techniques that can be used to automatically translate existing imperative code to functional variants using these APIs. Motivated by this problem, this paper presents a transpilation approach based on inductive program synthesis for modernizing existing code. Our method is based on the observation that the overwhelming majority of source/target programs in this setting satisfy an assumption that we call trace-compatibility: not only do the programs share syntactically identical low-level expressions, but these expressions also take the same values in corresponding execution traces. Our method leverages this observation to design a new neural-guided synthesis algorithm that (1) uses a novel neural architecture called cognate grammar network (CGN) and (2) leverages a form of concolic execution to prune partial programs based on intermediate values that arise during a computation. We have implemented our approach in a tool called NGST2 and use it to translate imperative Java and Python code to functional variants that use the Stream and functools APIs respectively. Our experiments show that NGST2 significantly outperforms several baselines and that our proposed neural architecture and pruning techniques are vital for achieving good results.

Flexible Example-Based Program Synthesis on Tree-Structured Function Compositions

We introduce a flexible program synthesis system whose task is to predict function compositions that transform given inputs to their corresponding given outputs. We process input lists in a sequential manner, allowing the system to generalize to a wide range of input lengths. We separate the operator and the operand in the lambda functions of the used higher order functions to achieve significantly wider numeric parameter ranges compared to the previous works. The evaluations show that this approach is competitive with state-of-the-art systems, while it is much more flexible in terms of the input length, the parameters of the lambda functions, and the integer range of the inputs and outputs. We extend the system to handle tree-structured function compositions by introducing two additional functions (zip_with, copy) and the ability to represent unfinished function compositions during the synthesis process. The extended system achieves state-of-the-art results while synthesizing complex function compositions with multiple forks. We believe that flexibility in these aspects is an important step towards solving real-world problems with example-based program synthesis.

Algebra-Based Reasoning for Loop Synthesis

Provably correct software is one of the key challenges of our software-driven society. Program synthesis—the task of constructing a program satisfying a given specification—is one strategy for achieving this. The result of this task is then a program that is correct by design. As in the domain of program verification, handling loops is one of the main ingredients to a successful synthesis procedure. We present an algorithm for synthesizing loops satisfying a given polynomial loop invariant. The class of loops we are considering can be modeled by a system of algebraic recurrence equations with constant coefficients, thus encoding program loops with affine operations among program variables. We turn the task of loop synthesis into a polynomial constraint problem by precisely characterizing the set of all loops satisfying the given invariant. We prove soundness of our approach, as well as its completeness with respect to an a priori fixed upper bound on the number of program variables. Our work has applications toward synthesizing loops satisfying a given polynomial loop invariant—program verification—as well as generating number sequences from algebraic relations. To understand viability of the methodology and heuristics for synthesizing loops, we implement and evaluate the method using the Absynth tool.

SYNTHESIS OF THERMAL DIAGNOSTIC EXPERT COMPONENTS WITH AN ARTIFICIAL NEURON

The article analyzes the automation tools in which artificial neural networks are used. It has been considered examples of effective use of hardware solutions with software versions of artificial neurons and other components, which allow to expand the functional properties of automation, while lowering the requirements for used computing facilities. On the example of electric motors intelligent technical diagnostics, it has been noted the possibility of assessing the technical state of complex electromechanical systems. The purpose of this work was to develop algorithms for computing and logical cycles suitable for the synthesis of a thermal diagnostic expert with an artificial neural network capable of identifying expected faults in electromechanical equipment of any complexity. It has been proposed a modular structure of the neural network software, an algorithm for the rate of temperature change, an artificial neuron module and other components. Simulation modeling and hardware implementation of an artificial neuron confirmed the suitability of the proposed solutions for the implementation of a diagnostic thermal examination device. The use of experimental data in electronic components made it possible to obtain a calibration characteristic for its subsequent use in assessing the development trend of possible non-standardized thermal events that appear when malfunctions are activated in certain parts of the operating equipment. It has been given variants of diagnostic expertise and identification of thermal events, preceding possible faults in the elements of electromechanical devices. It has been considered real examples of the main user program synthesis, taking into account access to the necessary settings of the hardware and control parts of the diagnostic device. It has been presented the illustrations of changing interfaces, which visual advantages lead to increased perception of the provided and associated computational functional properties of the diagnostic device when operating by users without special training. The applied solutions and visual examples of experimental and simulation modeling of the developed components of a thermal diagnostic expert with an artificial neural network are presented in the work.

Program Synthesis of Sparse Algorithms for Wave Function and Energy Prediction in Grid-Based Quantum Simulations.

We have recently shown how program synthesis (PS), or the concept of “self-writing code”, can generate novel algorithms that solve the vibrational Schrödinger equation, providing approximations to the allowed wave functions for bound, one-dimensional (1-D) potential energy surfaces (PESs). The resulting algorithms use a grid-based representation of the underlying wave function ψ(x) and PES V(x), providing codes which represent approximations to standard discrete variable representation (DVR) methods. In this Article, we show how this inductive PS strategy can be improved and modified to enable prediction of both vibrational wave functions and energy eigenvalues of representative model PESs (both 1-D and multidimensional). We show that PS can generate algorithms that offer some improvements in energy eigenvalue accuracy over standard DVR schemes; however, we also demonstrate that PS can identify accurate numerical methods that exhibit desirable computational features, such as employing very sparse (tridiagonal) matrices. The resulting PS-generated algorithms are initially developed and tested for 1-D vibrational eigenproblems, before solution of multidimensional problems is demonstrated; we find that our new PS-generated algorithms can reduce calculation times for grid-based eigenvector computation by an order of magnitude or more. More generally, with further development and optimization, we anticipate that PS-generated algorithms based on effective Hamiltonian approximations, such as those proposed here, could be useful in direct simulations of quantum dynamics via wave function propagation and evaluation of molecular electronic structure.

Co-Optimization of Design and Fabrication Plans for Carpentry

Past work on optimizing fabrication plans given a carpentry design can provide Pareto-optimal plans trading off between material waste, fabrication time, precision, and other considerations. However, when developing fabrication plans, experts rarely restrict to a single design , instead considering families of design variations , sometimes adjusting designs to simplify fabrication. Jointly exploring the design and fabrication plan spaces for each design is intractable using current techniques. We present a new approach to jointly optimize design and fabrication plans for carpentered objects. To make this bi-level optimization tractable, we adapt recent work from program synthesis based on equality graphs (e-graphs), which encode sets of equivalent programs. Our insight is that subproblems within our bi-level problem share significant substructures. By representing both designs and fabrication plans in a new bag of parts (BOP) e-graph, we amortize the cost of optimizing design components shared among multiple candidates. Even using BOP e-graphs, the optimization space grows quickly in practice. Hence, we also show how a feedback-guided search strategy dubbed Iterative Contraction and Expansion on E-graphs (ICEE) can keep the size of the e-graph manageable and direct the search towards promising candidates. We illustrate the advantages of our pipeline through examples from the carpentry domain.

Synthesis of trigonometric motion programs with lower motion characteristics

Abstract. Motion characteristics are dimensionless peak values of velocity, acceleration, jerk, and acceleration multiplied by velocity of a motion program. In general, these peak values of synthesized motion programs should be as low as possible. Some trigonometric motion programs are widely used because they have a good compromise of all motion characteristics. A property in common for trigonometric motion programs is that their acceleration functions can be expressed as a qualitative shape of a sinusoidal function. The interval of the sinusoidal function is divided into several zones having different linear slopes. The acceleration function can be easily shaped by specifying presented phase angle function to synthesize desired motion programs. To improve the kinematic quantities of trigonometric motion programs, this paper addresses an alternative phase angle function to obtain synthesized motion programs with simultaneous reduction in all the motion characteristics. The synthesis process and results are illustrated by examples.

Bottom-up synthesis of recursive functional programs using angelic execution

We present a novel bottom-up method for the synthesis of functional recursive programs. While bottom-up synthesis techniques can work better than top-down methods in certain settings, there is no prior technique for synthesizing recursive programs from logical specifications in a purely bottom-up fashion. The main challenge is that effective bottom-up methods need to execute sub-expressions of the code being synthesized, but it is impossible to execute a recursive subexpression of a program that has not been fully constructed yet. In this paper, we address this challenge using the concept of angelic semantics. Specifically, our method finds a program that satisfies the specification under angelic semantics (we refer to this as angelic synthesis), analyzes the assumptions made during its angelic execution, uses this analysis to strengthen the specification, and finally reattempts synthesis with the strengthened specification. Our proposed angelic synthesis algorithm is based on version space learning and therefore deals effectively with many incremental synthesis calls made during the overall algorithm. We have implemented this approach in a prototype called Burst and evaluate it on synthesis problems from prior work. Our experiments show that Burst is able to synthesize a solution to 94% of the benchmarks in our benchmark suite, outperforming prior work.

Methodology support and algorithms for dynamic synthesis of technologies and programs for proactive management of information processes in the industrial internet under a crisis

The impact of digitalisation on disruption risk control in the cyber-physical systems (CPS) functioning is studied. The paper is devoted to methodological support and algorithms for the dynamic synthesis of technologies and control programs of information processes in the Industrial Internet of Things (IIoT) under a crisis. Generalised examples of the considered approach implementation in the field of integrated planning of CPS functioning and evaluating the robustness of synthesised programs are given.

Program Synthesis Through Learning the Input-Output Behavior of Commands

Program synthesis writes programs on behalf of humans, increasing software development productivity. Existing systems select a proper sequence of commands by assembling them in various ways and analyzing their meanings, which is accurate and fast when a detailed specification is given for each available command, including the syntax and semantics. However, preparing this specification is burdensome and must be repeated to add or modify available commands. We propose a synthesis system that requires moderate groundwork to achieve sufficient accuracy and speed. The proposed system receives the syntax of the available commands and learns their meanings independently by writing programs and observing their input-output behavior. Using the learned knowledge, the system selects a likely sequence of commands and gradually revises them to converge to a target program. We validated the system by synthesizing 1,000 integer-manipulation programs out of 245,410 possible programs. The system synthesized most of the programs within 1,000 revisions, which is 80% faster than the state-of-the-art system based on machine-learned input-output patterns. In addition, greater than 10% of the programs were synthesized within several revisions. We believe that the proposed system provides a basis for synthesis systems based on learning input-output behavior.

Synthesis of modeling programs based on multi-version component libraries

Synthesis of modeling programs based on multi-version component libraries

Methodology support and algorithms for dynamic synthesis of technologies and programs for proactive management of information processes in the industrial internet under a crisis

Methodology support and algorithms for dynamic synthesis of technologies and programs for proactive management of information processes in the industrial internet under a crisis

Conference reports

In this new installment, Niccolò Veltri (Tallinn University of Technology) reports on the 23rd International Symposium on Principles and Practice of Declarative Programming (PPDP 2021) and the 31st International Symposium on Logic-based Program Synthesis and Transformation (LOPSTR 2021), two co-located symposia for which he served as general chair.

Neural Network Approach to Program Synthesis for Tabular Transformation by Example

Data transformation is a laborious and time-consuming task for analysts. Programming by example (PBE) is a technique that can simplify this difficult task for data analysts by automatically generating programs for data transformation. Most of the previously proposed PBE methods are based on search algorithms, but recent improvements in machine learning (ML) have led to its application in PBE research. For example, RobustFill was proposed as an ML-based PBE method for string transformation by using long short-term memory (LSTM) as the sequential encoder–decoder model. However, an ML-based PBE method has not been developed for tabular transformations, which are used frequently in data analysis. Thus, in the present study, we propose an ML-based PBE method for tabular transformations. First, we consider the features of tabular transformations, which are more complex and data intensive than string transformations, and propose a new ML-based PBE method using the state-of-the-art Transformer sequential encoder–decoder model. To our knowledge, this is the first ML-based PBE method for tabular transformations. We also propose two decoding methods comprising multistep beam search and program validation-beam search, which are optimized for program generation, and thus generate correct programs with higher accuracy. Our evaluation results demonstrated that the Transformer-based PBE model performed much better than LSTM-based PBE when applied to tabular transformations. Furthermore, the Transformer-based model with the proposed decoding method performed better than the conventional PBE model using the search-based method.

Input-Output Example-Guided Data Deobfuscation on Binary

Data obfuscation is usually used by malicious software to avoid detection and reverse analysis. When analyzing the malware, such obfuscations have to be removed to restore the program into an easier understandable form (deobfuscation). The deobfuscation based on program synthesis provides a good solution for treating the target program as a black box. Thus, deobfuscation becomes a problem of finding the shortest instruction sequence to synthesize a program with the same input-output behavior as the target program. Existing work has two limitations: assuming that obfuscated code snippets in the target program are known and using a stochastic search algorithm resulting in low efficiency. In this paper, we propose fine-grained obfuscation detection for locating obfuscated code snippets by machine learning. Besides, we also combine the program synthesis and a heuristic search algorithm of Nested Monte Carlo Search. We have applied a prototype implementation of our ideas to data obfuscation in different tools, including OLLVM and Tigress. Our experimental results suggest that this approach is highly effective in locating and deobfuscating the binaries with data obfuscation, with an accuracy of at least 90.34%. Compared with the state-of-the-art deobfuscation technique, our approach’s efficiency has increased by 75%, with the success rate increasing by 5%.

Automata theory approach to predicate intuitionistic logic

Abstract Predicate intuitionistic logic is a well-established fragment of dependent types. Proof construction in this logic, as the Curry–Howard isomorphism states, is the process of program synthesis. We present automata that can handle proof construction and program synthesis in full intuitionistic first-order logic. Given a formula, we can construct an automaton such that the formula is provable if and only if the automaton has an accepting run. As further research, this construction makes it possible to discuss formal languages of proofs or programs, the closure properties of the automata and their connections with the traditional logical connectives.

LooPy: interactive program synthesis with control structures

One vision for program synthesis, and specifically for programming by example (PBE), is an interactive programmer's assistant, integrated into the development environment. To make program synthesis practical for interactive use, prior work on Small-Step Live PBE has proposed to limit the scope of synthesis to small code snippets, and enable the users to provide local specifications for those snippets. This paradigm, however, does not work well in the presence of loops. We present LooPy, a synthesizer integrated into a live programming environment, which extends Small-Step Live PBE to work inside loops and scales it up to synthesize larger code snippets, while remaining fast enough for interactive use. To allow users to effectively provide examples at various loop iterations, even when the loop body is incomplete, LooPy makes use of live execution , a technique that leverages the programmer as an oracle to step over incomplete parts of the loop. To enable synthesis of loop bodies at interactive speeds, LooPy introduces Intermediate State Graph , a new data structure, which compactly represents a large space of code snippets composed of multiple assignment statements and conditionals. We evaluate LooPy empirically using benchmarks from competitive programming and previous synthesizers, and show that it can solve a wide variety of synthesis tasks at interactive speeds. We also perform a small qualitative user study which shows that LooPy's block-level specifications are easy for programmers to provide.

Solving the Schrödinger equation using program synthesis.

We demonstrate that a program synthesis approach based on a linear code representation can be used to generate algorithms that approximate the ground-state solutions of one-dimensional time-independent Schrödinger equations constructed with bound polynomial potential energy surfaces (PESs). Here, an algorithm is constructed as a linear series of instructions operating on a set of input vectors, matrices, and constants that define the problem characteristics, such as the PES. Discrete optimization is performed using simulated annealing in order to identify sequences of code-lines, operating on the program inputs that can reproduce the expected ground-state wavefunctions ψ(x) for a set of target PESs. The outcome of this optimization is not simply a mathematical function approximating ψ(x) but is, instead, a complete algorithm that converts the input vectors describing the system into a ground-state solution of the Schrödinger equation. These initial results pointthe way toward an alternative route for developing novel algorithms for quantum chemistry applications.

Gauss: program synthesis by reasoning over graphs

While input-output examples are a natural form of specification for program synthesis engines, they can be imprecise for domains such as table transformations. In this paper, we investigate how extracting readily-available information about the user intent behind these input-output examples helps speed up synthesis and reduce overfitting. We present Gauss, a synthesis algorithm for table transformations that accepts partial input-output examples, along with user intent graphs. Gauss includes a novel conflict-resolution reasoning algorithm over graphs that enables it to learn from mistakes made during the search and use that knowledge to explore the space of programs even faster. It also ensures the final program is consistent with the user intent specification, reducing overfitting. We implement Gauss for the domain of table transformations (supporting Pandas and R), and compare it to three state-of-the-art synthesizers accepting only input-output examples. We find that it is able to reduce the search space by 56×, 73× and 664× on average, resulting in 7×, 26× and 7× speedups in synthesis times on average, respectively.

APIfix: output-oriented program synthesis for combating breaking changes in libraries

Use of third-party libraries is extremely common in application software. The libraries evolve to accommodate new features or mitigate security vulnerabilities, thereby breaking the Application Programming Interface(API) used by the software. Such breaking changes in the libraries may discourage client code from using the new library versions thereby keeping the application vulnerable and not up-to-date. We propose a novel output-oriented program synthesis algorithm to automate API usage adaptations via program transformation. Our aim is not only to rely on the few example human adaptations of the clients from the old library version to the new library version, since this can lead to over-fitting transformation rules. Instead, we also rely on example usages of the new updated library in clients, which provide valuable context for synthesizing and applying the transformation rules. Our tool APIFix provides an automated mechanism to transform application code using the old library versions to code using the new library versions - thereby achieving automated API usage adaptation to fix the effect of breaking changes. Our evaluation shows that the transformation rules inferred by APIFix achieve 98.7% precision and 91.5% recall. By comparing our approach to state-of-the-art program synthesis approaches, we show that our approach significantly reduces over-fitting while synthesizing transformation rules for API usage adaptations.