Program Synthesis Research Articles

Improving Oracle-Guided Inductive Synthesis by Efficient Question Selection

Oracle-guided inductive synthesis (OGIS) is a widely-used framework to apply program synthesis techniques in practice. The question selection problem aims at reducing the number of iterations in OGIS by selecting a proper input for each OGIS iteration. Theoretically, a question selector can generally improve the performance of OGIS solvers on both interactive and non-interactive tasks if it is not only effective for reducing iterations but also efficient. However, all existing effective question selectors fail in satisfying the requirement of efficiency. To ensure effectiveness, they convert the question selection problem into an optimization one, which is difficult to solve within a short time. In this paper, we propose a novel question selector, named LearnSy . LearnSy is both efficient and effective and thus achieves general improvement for OGIS solvers for the first time. Since we notice that the optimization tasks in previous studies are difficult because of the complex behavior of operators, we estimate these behaviors in LearnSy as simple random events. Subsequently, we provide theoretical results for the precision of this estimation and design an efficient algorithm for its calculation. According to our evaluation, when dealing with interactive tasks, LearnSy can offer competitive performance compared to existing selectors while being more efficient and more general. Moreover, when working on non-interactive tasks, LearnSy can generally reduce the time cost of existing CEGIS solvers by up to 43.0%.

Learning programs with magic values

A magic value in a program is a constant symbol that is essential for the execution of the program but has no clear explanation for its choice. Learning programs with magic values is difficult for existing program synthesis approaches. To overcome this limitation, we introduce an inductive logic programming approach to efficiently learn programs with magic values. Our experiments on diverse domains, including program synthesis, drug design, and game playing, show that our approach can (1) outperform existing approaches in terms of predictive accuracies and learning times, (2) learn magic values from infinite domains, such as the value of pi, and (3) scale to domains with millions of constant symbols.

K‐Go: An executable formal semantics of Go language in K framework

AbstractGo is a relatively new programming language and has become one of the most important programming languages used widely in blockchain. A formal semantics plays an important role in program synthesis, analysis and verification. The existed formal semantics of Go are not executable and do not cover the core features, hence, this paper presents an executable formal semantics for Go, called K‐Go, using rewriting logic in framework to make sure the semantics is both executable and applicable. K‐Go includes syntax, configuration and rules and covers the declaration and definition of basic types, basic expression, concurrency, main statement data reading and writing based on channel. K‐Go is validated by test set with 100% semantic coverage based on the official test suite. The evaluation experiment shows that K‐Go is correct. Using formal semantics of Go language, building Go program synthesis, analysis and verification tools is easy for analyzing more characteristics of Go programs.

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Leveraging Rust Types for Program Synthesis

Towards Porting Operating Systems with Program Synthesis

The end of Moore’s Law has ushered in a diversity of hardware not seen in decades. Operating system (OS) (and system software) portability is accordingly becoming increasingly critical. Simultaneously, there has been tremendous progress in program synthesis. We set out to explore the feasibility of using modern program synthesis to generate the machine-dependent parts of an operating system. Our ultimate goal is to generate new ports automatically from descriptions of new machines. One of the issues involved is writing specifications, both for machine-dependent operating system functionality and for instruction set architectures. We designed two domain-specific languages: Alewife for machine-independent specifications of machine-dependent operating system functionality and Cassiopea for describing instruction set architecture semantics. Automated porting also requires an implementation. We developed a toolchain that, given an Alewife specification and a Cassiopea machine description, specializes the machine-independent specification to the target instruction set architecture and synthesizes an implementation in assembly language with a customized symbolic execution engine. Using this approach, we demonstrate the successful synthesis of a total of 140 OS components from two pre-existing OSes for four real hardware platforms. We also developed several optimization methods for OS-related assembly synthesis to improve scalability. The effectiveness of our languages and ability to synthesize code for all 140 specifications is evidence of the feasibility of program synthesis for machine-dependent OS code. However, many research challenges remain; we also discuss the benefits and limitations of our synthesis-based approach to automated OS porting.

Program Synthesis for Cyber-Resilience

Architectural tactics enable stakeholders to achieve cyber-resilience requirements. They permit systems to react, resist, detect, and recover from cyber incidents. This paper presents an approach to generate source code for architectural tactics typically used in safety and mission-critical systems. Our approach extensively relies on the use of the <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Event-B</small> formal method and the <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">EventB2Java</small> code generation plugin of the Rodin platform. It leverages the modeling of architectural tactics in the <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Event-B</small> formal language and uses a set of <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">EventB2Java</small> transformation rules to generate certified code implementations for the said tactics. Since resilience requirements are statements about a system over time, and because of the fact that the <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Event-B</small> language does not provide (native) support for the writing of temporal specifications, we have implemented a novel Linear Temporal Logic (LTL) extension for <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Event-B</small> . We support several architectural tactics for availability, performance, and security. The generated code is certified in the following sense: discharging proof obligations in Rodin - the platform we use for writing the <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Event-B</small> models - attests to the soundness of the architectural tactics modelled in <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Event-B</small> , and the soundness of the translation encoded by the <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">EventB2Java</small> tool attests to the code correctness. Finally, we demonstrate the usability of our resilience validation approach with the aid of an Autonomous Vehicle System. It further helped us increase our confidence in the soundness of our Event-B LTL extension.

PARAMETER-DRIVEN GENERATION OF EVALUATION PROGRAM FOR A NEUROEVOLUTION ALGORITHM ON A BINARY MULTIPLEXER EXAMPLE

Context. The problem of automated development of evaluation programs for the neuroevolution of augmenting topologies. Neuroevolution algorithms apply mechanisms of mutation, recombination, and selection to find neural networks with behavior that satisfies the conditions of a certain formally defined problem. An example of such a problem is finding a neural network that implements a certain digital logic.&#x0D; Objective. The goal of the work is the automated design and generation of an evaluation program for a sample neuroevolution problem (binary multiplexer).&#x0D; Method. The methods and tools of Glushkov’s algebra of algorithms and hyperscheme algebra are applied for the parameterdriven generation of a neuroevolution evaluation program for a binary multiplexer. Glushkov’s algebra is the basis of the algorithmic language intended for multilevel structural design and documentation of sequential and parallel algorithms and programs in a form close to a natural language. Hyperschemes are high-level parameterized specifications intended for solving a certain class of problems. Setting parameter values and subsequent interpretation of hyperschemes allows obtaining algorithms adapted to specific conditions of their use.&#x0D; Results. The facilities of hyperschemes were implemented in the developed integrated toolkit for the automated design and synthesis of programs. Based on algorithm schemes, the system generates programs in a target programming language. The advantage of the system is the possibility of describing algorithm schemes in a natural-linguistic form. An experiment was conducted consisting in the execution of the generated program for the problem of evaluating a binary multiplexer on a distributed cloud platform. The multiplexer example is included in SharpNEAT, an open-source framework that implements the genetic neuroevolution algorithm NEAT for the .NET platform. The parallel distributed implementation of the SharpNEAT was proposed in the previous work of the authors.&#x0D; Conclusions. The conducted experiments demonstrated the possibility of the developed distributed system to perform evaluations on 64 cloud clients-executors and obtain an increase in 60–100% of the maximum capabilities of a single-processor local implementation.

THE STAFFING CONCEPT REFORM OF THE FORENSIC MEDICAL SERVICE OF UKRAINE

The foreign experience in the training of forensic experts is analyzed in the article. This experience is compared with the corresponding training system for forensic doctors that existed in Ukraine until 2022. A reasoned assessment of the reform of the training of forensic medical experts in Ukraine is given. Proposals have been made to change this reform, which consist in the fact that pathologists would be trained instead of pathologist doctors. The proposed concept of a training program for pathologists is a synthesis of training programs for pathologists and forensic medical experts. According to the authors’concept of the pathologist should acquire a sufficient amount of competencies for practical work as a pathologist and a scope of competencies that will be acceptable for training a forensic medical expert on its basis.

Synthesizing explainable counterfactual policies for algorithmic recourse with program synthesis

Being able to provide counterfactual interventions—sequences of actions we would have had to take for a desirable outcome to happen—is essential to explain how to change an unfavourable decision by a black-box machine learning model (e.g., being denied a loan request). Existing solutions have mainly focused on generating feasible interventions without providing explanations of their rationale. Moreover, they need to solve a separate optimization problem for each user. In this paper, we take a different approach and learn a program that outputs a sequence of explainable counterfactual actions given a user description and a causal graph. We leverage program synthesis techniques, reinforcement learning coupled with Monte Carlo Tree Search for efficient exploration, and rule learning to extract explanations for each recommended action. An experimental evaluation on synthetic and real-world datasets shows how our approach, FARE (eFficient counterfActual REcourse), generates effective interventions by making orders of magnitude fewer queries to the black-box classifier with respect to existing solutions, with the additional benefit of complementing them with interpretable explanations.

A Comprehensive Survey on Program Synthesis With Evolutionary Algorithms

The automatic generation of computer programs is one of the main applications with practical relevance in the field of evolutionary computation. With program synthesis techniques not only software developers could be supported in their everyday work but even users without any programming knowledge could be empowered to automate repetitive tasks and implement their own new functionality. In recent years, many novel program synthesis approaches based on evolutionary algorithms have been proposed and evaluated on common benchmark problems. Therefore, we identify and discuss in this survey the relevant evolutionary program synthesis approaches in the literature and provide an in-depth analysis of their performance. The most influential approaches we identify are stack-based, grammar-guided, as well as linear genetic programming (GP). For the stack-based approaches, we identify 37 in-scope papers, and for the grammar-guided and linear GP approaches, we identify 12 and 5 papers, respectively. Furthermore, we find that these approaches perform well on benchmark problems if there is a simple mapping from the given input to the correct output. On problems where this mapping is complex, e.g., if the problem consists of several subproblems or requires iteration/recursion for a correct solution, results tend to be worse. Consequently, for future work, we encourage researchers not only to use a program’s output for assessing the quality of a solution but also the way toward a solution (e.g., correctly solved subproblems).

How is Trauma-Informed Education Implemented within Classrooms? A Synthesis of Trauma-Informed Education Programs

How is Trauma-Informed Education Implemented within Classrooms? A Synthesis of Trauma-Informed Education Programs

Quantum Program Synthesis Through Operator Learning and Selection

Programming for quantum computers is complicated and time consuming, because quantum operations are counterintuitive and their combined effects are difficult to understand. Existing tools allow automatic synthesis of quantum programs, which releases the burden of handwriting. However, many existing systems arrange predetermined operators in successive manner to gradually reduce the gap with requirements; these methods are quick but often produce lengthy programs, and they are difficult to adopt for new operators. Other systems depend on stochastic or heuristic search; they identify near-optimal programs for certain cases, but it is not easy to tune the algorithms for a wide range of cases. We propose a system that produces compact programs for most cases and easily evolves with new operators. The system automatically learns the roles of available operators by composing various possible programs. Based on the knowledge, it selects a subset of operators most appropriate for requirements and uses them to compose a program. The learning is geared toward concise programs; thus, the system tends to produce programs with the fewest operators possible. We implemented the system and evaluated it by synthesizing over 400 programs. In comparison with a state-of-the-art system, the proposed system produced programs with approximately 40-times fewer operators at the cost of increased synthesis time from seconds to minutes. We also observed that the system successfully adopted new operators by learning their differences from existing operators and utilizing them in right places. We believe that the system provides a basis of utilizing machine learning for quantum program synthesis.

Information technology of IT-infrastructure management architecture elements

The development of the System Architecture of the IT-infrastructure focused on the use of modern Data Centers is considered. At the same time, it is envisaged to create components that describe: general approaches to building a system architecture; IT-services – information technologies that solve the task of providing IT-services; logical model of IT-infrastructure. Formulated logic of IT-infrastructure construction: IT-infrastructure architectures define a set of services. IT-services are provided to three groups of clients. IT-services and clients are connected by 5 implementation scenarios. The integration of IT-services is determined by 5 architectures. As IT-services, we understand information technologies aimed at maintaining the following elements in a technically good state: network devices, computing equipment, data storage devices, automatic software deployment services, network services, perimeter protection services, directory services, file and print services, data management services, business application services, IT-management services, archiving and recovery services, certificate management services, integration services. Architectures define the fundamental principles of building IT-services and their relationship. Also, requirements for the creation of IT-services are formed on the basis of the architecture. One of the most important architectures is architecture of IT-infrastructure management. The architecture of the management system ensures the necessary level of IT-services of the Data Center due to the organization of three components – personnel, processes, technologies. The tasks of the architecture are: use of processes and information technologies to identify and minimize failures of IT-services; ensuring a high degree of integration of information technologies; ensuring response to changes in system parameters and performance of service functions in real time. As an example, the management function of the IT-service “network administration” (monitoring and control of configuration management services, coordination of changes, remote management and debugging) is considered. The algorithmic synthesis of programs and devices network management is considered, which consists in the construction of a functional scheme of control devices in two stages – abstract and structural synthesis, and all the steps of its solution and subsequent hardware synthesis are determined.

Автоматизована генерація програм для одного класу параметричних алгоритмів нейроеволюції

The facilities of algebra of hyperschemes are applied for automated generation of neuroevolution algorithms on an example of a binary multiplexer evaluation problem, which is a part of the SharpNEAT system. SharpNEAT is an open-source framework developed in C# programming language, which implements a genetic neuroevolution algorithm for the .NET platform. Neuroevolution is a form of artificial intelligence, which uses evolution algorithms for creating neural networks, parameters, topology, and rules. Evolution algorithms apply mutation, recombination, and selection mechanisms for finding neural networks with behavior that satisfies to conditions of some formally defined problem. In this paper, we demonstrate the use of algebra of algorithms and hyperschemes for the automated generation of evaluation programs for neuroevolution problems. Hyperscheme is a high-level parameterized specification of an algorithm for solving some class of problems. Setting the values of the hyperscheme parameters and further interpretation of a hyperscheme allows obtaining algorithms adapted to specific conditions of their use. Automated construction of hyperschemes and generation of algorithms based on them is implemented in the developed integrated toolkit for design and synthesis of programs. The design of algorithms is based on Glushkov systems of algorithmic algebra. The schemes are built using a dialogue constructor of syntactically correct programs, which consists in descending design of algorithms by detailing the constructions of algorithmic language. The design is represented as an algorithm tree. Based on algorithm schemes, programs in a target programming language are generated. The results of the experiment consisting in executing the generated binary multiplexer evaluating program on a cloud platform are given.