1 Introduction
Program synthesis (or synthesis for short) is a special class of regression problems where rather than minimizing the error on an example dataset, one seeks an exact fit of the examples in the form of a program. Applications include synthesizing database relations (Singh et al., 2017), inferring excelformulas (Gulwani et al., 2012), and compilation (Phothilimthana et al., 2016). The synthesized programs are complex, consisting of branches and loops. Recent efforts (Ellis et al., 2015; Singh et al., 2017) show an interest in applying the synthesis technique to large sets of examples, but scalability remains a challenge. We present a method that selects a small representative subset of examples from a dataset, such that it is sufficient to specify a correct program, yet small enough to encode efficiently.
There are two key ingredients to a synthesis problem: a domain specific language (DSL for short) and a specification. The DSL defines a space of candidate programs which serve as the model class. The specification is commonly expressed as a set of inputoutput examples which the candidate program needs to fit exactly. The DSL restricts the structure of the programs in such a way that it is impossible to fit the inputoutput examples in an adhoc fashion: This structure aids generalization to an unseen input despite fitting the training examples exactly.
Given the precise and combinatorial nature of synthesis, gradientdescent based approaches perform poorly and an explicit search over the solution space is required (Gaunt et al., 2016). For this reason, synthesis is commonly casted as a constraint satisfaction problem (CSP) (SolarLezama, 2013; Jha et al., 2010). In such a setting, the DSL and its execution can be thought of as a parametrized function , which is encoded as a logical formula. Its parameters correspond to different instantiations of programs within the DSL, and the inputoutput examples are expressed as constraints which the instantiated program needs to satisfy, namely, producing the correct output on a given input.
The encoded formula is then given to a constraint solver such as Z3 (de Moura & Bjørner, 2008), which solves the constraint problem, producing a set of valid parameter values for . These values are then used to instantiate the DSL into a concrete, executable program.
A key challenge
of framing a synthesis problem as a CSP is that of scalability. While solvers have powerful heuristics to efficiently prune and search the constrained search space, constructing and maintaining the symbolic formula over a large number of constraints constitutes a serious overhead
^{1}^{1}1However, if the solver does manage to construct and maintain all the constraints, solving the constraints can be fast as the constraints allow the solver to prune the search space.. Developers of synthesis systems put significant effort into simplifying and rewriting the constraint formula into a more compact representation (Singh & SolarLezama, 2016; Cadar et al., 2008). Nonetheless, to apply program synthesis to a large dataset, one needs to limit the number of examples expressed as constraints.The standard method to limit the number of examples is CEGIS (counter example guided inductive synthesis) (SolarLezama et al., 2006)
. CEGIS employs two adversarial subroutines, a synthesizer and a checker: The synthesizer solves the CSP on a subset of examples rather than on the whole set, producing a candidate program; the checker takes the candidate program and produces an adversarial counter example that invalidates the candidate program. This adversarial example is then added to the subset of examples, prompting the synthesizer to improve. CEGIS successfully terminates when the checker fails to produce an adversarial example. By iteratively adding counter examples to the subset as needed, CEGIS can drastically reduce the size of the constraints constructed by the synthesizer, making it scalable to large datasets. However, CEGIS has to repeatedly invoke the constraint solver in the synthesis subroutine, solving a sequence of challenging CSP problems. Moreover, due to the phase transition
(Gent & Walsh, 1994) property of SAT formulas, there may be instances in the sequence of CSPs with enough constraints to make the problem difficult, yet not enough constraints for the solver to prune the search space^{2}^{2}2Imagine a mostly empty Sudoku puzzle, the first few numbers and the last few numbers are easy to fill, whereas the intermediate set of numbers are the most challenging, making the performance of CEGIS volatile.We describe a method that iteratively construct a representative subset of examples, which is both sufficient to specify a correct program and small enough to encode efficiently by a constraint solver. The algorithm is greedy: Starting with a (potentially empty) subset of examples, it uses a pretrained neural network to compute the probability of other examples not in the subset conditioned on the subset, and extends the subset with the most “surprising” example (one with the smallest probability). The reason being if an example has a low probability conditioned on the given subset, then it is the most constraining example that can maximally prune the search space once added. The algorithm stops when all the inputoutput examples have a sufficiently high probability. Experiments show that our method does find representative subsets most of the times, and significantly improves synthesis time and stability on the the tasks of automaton induction and inverse rendering against strong baselines.
2 An Example Synthesis Problem
To best illustrate the synthesis problem and explain our approach, consider a diagram drawing DSL (Ellis et al., 2017) that allows a user to draw squares and lines. The DSL defines a function, which maps a pixelcoordinate to a boolean value indicating whether the specified pixel coordinate is contained within one of the shapes. By calling the function across a canvas, one obtains a rendering of the image where a pixel coordinate is colored white if it is contained in one of the shapes, and black otherwise. Figure 1 shows an example of a draw function and its generated rendering on a 32 by 32 pixel grid. The DSL contains a set of parameters that allows the function to express different diagrams, which are in bold in Figure 1(left). The synthesis task is: Given a diagram rendered in pixels, discover the parameter values in the draw function so that it can reproduce the same rendering.
The synthesized drawing program is correct when its rendered image matches the target rendering exactly. As the DSL contains control flow structures such as “for” and “if”, it is a difficult combinatorial problem that requires the use of a constraint solver. Let be the synthesized draw function and be the target rendering:
Here, each of the pixels in the target render is encoded as an inputoutput pair that generates a distinct constraint on all of the parameters. For the 32 by 32 pixel image, a conjunction of 1024 distinct constraints are generated, which impose a significant encoding overhead.
In this paper, we propose an algorithm that approximates a representative subset of inputoutput examples. This subset is small, which alleviates the encoding overhead, yet remains representative of all the examples so that it sufficiently specifies the correctness condition. Figure 2 (top, left) shows the subset chosen by our algorithm. As we can see, from a total of 1024 examples, only 15% are selected for the representative subset. The representative subset is then given to the constraint solver, recovering the hidden parameter values in Figure 2 (top, right). By comparison, the CEGIS algorithm chooses a much smaller number of examples that are not representative, Figure 2 (bottom, left): Despite the small size of the subset, since it is not representative, CEGIS ultimately achieves a longer solving time.
Our algorithm constructs the representative subset iteratively. Starting with an empty subset, the algorithm uses a neural network to compute the probability of all the examples conditioned on the chosen examples in the subset. It then adds the least probable example to the subset, the intuition being the example with the lowest probability would best prune the search space as a constraint. The algorithm terminates when all the examples in the dataset are given a sufficiently high probability. An example execution of our selection algorithm is shown in Figure 3. The rest of the paper elaborates our approach.
3 Discovering Representative Examples
The crux of our algorithm is an example selection scheme, which takes in a set of examples and outputs a small subset of representative examples. Let be a subset of examples. Abusing notation, let us define the consistency constraint , that is to say, the parameter^{3}^{3}3We’ll refer to as either a “parameter” or a “program” from now on, whichever is most appropriate given the context. is consistent with all examples in . We define the optimal representative subset as:
is representative of in a sense any parameter satisfying must also satisfy . Finding the exact minimum sized is often intractable, thus we focus on finding a sufficient subset that is as close in size to as possible.
3.1 Examples Selection: a Greedy Strategy
We start with an approximate algorithm with a count oracle , which counts the number of valid solutions with respect to a subset of examples: . Algorithm 1 constructs the subset greedily, choosing the example that maximally prunes the solution space.
Claim 1:
Algorithm 1 produces a subset that is representative, i.e. .
Proof 1:
As is defined as a conjunction of satisfying each example, can only be monotonically decreasing with each additional example/constraint: . At termination, the counts remain unchanged , meaning no more solutions can be invalidated. Thus we obtain the sufficiency condition .
Claim 2:
Let denotes the number of programs invalidated by , and the size of the optimal subset, then the greedy subset returned by Algorithm 1 satisfies
Lemma 2.1:
It will be helpful to first show that the function is both monotonic and submodular.
Proof 2.1:
To show monotonicity, note that the constraint generated by the examples are conjunctive, thus adding examples strictly increases the number of invalidated programs.
To show submodularity, we require for :
Let , the constraint stating that a program should satisfy , but fails to satisfy ; Similarly, let . Then, the count measures how many parameter becomes invalidated by introducing to , i.e. , similarly, . Note that and are conjunctive constraints, with strictly more constrained than due to . Thus , and we have submodularity of as claimed.
Proof 2:
We now derive an upper bound on the size of the representative subset returned by Algorithm 1. As is monotonic and submodular, Nemhauser et al. (1978) showed that for any optimal subset of size , the greedily constructed subset of size satisfies:
Let be the remaining number of solutions yet to be pruned by . After subtracting both sides of the inequality from :
Set , the size of the optimal representative subset, we can substitute with :
Algorithm 1 terminates when there are no more programs to prune, i.e. when :
Rearranging terms we see Algorithm 1 terminates when:
Unfortunately, this is a rather loose upperbound as the difference between and is quite small. However, in some instances it can still be helpful: If and , we have , which could be significantly smaller than . In the experiment section we explicitly measure the size of the subset returned by our algorithm, showing that in practice one could obtain much smaller subsets than this upperbound.
3.2 Example Selection: by Anticipating New Examples
We describe an alternative selection criteria that can be approximated efficiently with a neural network. Let’s write the selected subset as where denotes the inputoutput example to be added to . We define the anticipation probability:
Note that is not
a joint distribution on
and , but rather the probability for the event where the parameterized function maps the input to , conditioned on the event where is consistent with all the inputoutput examples in . We claim that one can use as an alternative to the count oracle .Claim 3:
Proof 3:
The probability can be written as a summation over all the possible parameter values for :
Note that under , we have:
And since is a function we have:
Thus the summation over all results in:
As is constant under given , we have as claimed.
It is easy to see that one needs to update the termination condition to , when all the inputoutput examples are completely anticipated given .
4 Neural Network Model
We now describe the high level neural network architecture that models the anticipation probability, .
4.1 Factorization: Enabling Scaling with
A challenge to our neural network encoding is the ability of our model to scale with the size of : as we might collect a large subset of examples, and the probability of each new example depends on the entire subset .
To address this, we make an independence assumption: Let be the neighborhood function that computes the topk neighbors of from and condition only on these topk neighbors:
We assume the programmer would be able to come up with an appropriate neighborhood function for each synthesis task. In our experiments, the neighborhood is measured by a distance metric on the input space
. For example, we have used a convolutional neural network (which implicitly uses pixel to pixel distance) and longest matching suffix (substring distance). Although we remark that in general, a neighborhood need not depend on a distance metric but can be as arbitrary as needed.
4.2 Anticipation Network: Direct Computation
Figure 4 (top) shows a neural network architecture that models the factorized anticipation probability directly.
We train the network on the task of correctly anticipating whether an inputoutput pair should occur based on the topk neighbors of from a subset . To do this, we sample a program and a subset of inputs . We evaluate the program on the set of inputs to produce a dataset of example pairs . We can then sample a subset and a new example . From this new example, we compute its topk neighbors . We also construct a negative sample by sampling a random . The network is then trained to produce on the input and to produce on the input
4.3 Committee Network: Peer Consultation
We now present an equivalent neural network architecture that affords a more intuitive understanding. Figure 4 (bot) shows the committee network, which computes an output distribution rather than the anticipation probability. The two architectures are equivalent because:
The committee network is trained on the task of producing the correct value , which has the implicit effect of negative sampling. This network has a very intuitive interpretation: To best predict the a function’s output on a new example , we consult the subset for the topk most relevant inputoutput pairs to make a prediction on the value of .
In practice, each synthesis domain would require a different neuralnetwork architecture, as the input/output types of the functions being synthesized and the neighborhood function are domain specific. However, the overall neuralnetwork task remains the same: predicting the function’s output on a new example based on the nearestk neighbors of already present in the subset . We’ll describe the domain specific architecture in detail in the Experiment section.
5 Synthesis with Representative Examples
The neural network cannot perfectly model the anticipation probability, thus, our example selection algorithm can only approximate a representative subset, causing the synthesized program to be inconsistent with the entire dataset of examples. We remedy this problem by combining example selection and CEGIS, getting the best of both worlds.
5.1 CEGIS: Guarantees with Caveats
CEGIS (SolarLezama et al., 2006) is a synthesis algorithm which guarantees total correctness on a set of examples . It is outlined in Algorithm 2. CEGIS is composed of two adversarial subroutines, a synthesizer and a checker: The synthesizer produces a candidate program over the subset , which is initially empty; The checker takes in this candidate program and produces an adversarial counter example which invalidates . is added to the subset of examples, prompting the synthesizer to improve. CEGIS successfully terminates when the checker fails to produce an adversarial example.
At first glance CEGIS is very similar to our approach, but a deeper look reveals several important differences. First, the subset of examples constructed by CEGIS upon termination is not representative: It is possible for CEGIS to synthesize the correct program without constructing a representative subset by luck, a fact we demonstrate empirically in the experiments. The danger of synthesis over a nonrepresentative subset is that there might be instances where there are enough constraints to make the synthesis problem challenging, yet not enough constraints for the solver to prune the search space. The result is the hanging of the solver for an extended periods of time, without any guarantee whether the synthesis would ever terminate. Secondly, to build the subset of counter examples, CEGIS must solve instances of constraint problems, each one with the potential to timeout due to being underconstrained.
5.2 Our Algorithm: Best of Both Worlds
Our algorithm combines representative example discovery and CEGIS by instantiating the subset of counter examples in CEGIS with a representative subset, see Algorithm 3. This algorithm guarantees complete correctness over the input dataset while alleviating the challenges of CEGIS by presenting CEGIS with a wellconstrained subset upfront.
6 Experiments
Our approach is evaluated against two criteria: First, the representativeness of our selected subset is explicitly measured; Then, the time/stability improvement of using such a subset is measured against several strong baselines.
6.1 Explicitly Measuring Representativeness
This experiment explicitly measures the representativeness of the subset selected by our algorithm on the task of ordering synthesis: Given a dataset of pairwise ordering relations, , the task is to synthesize any totalordering that is consistent with , for instance, or . This task is useful because the optimal representative subset can be constructed as a Hasse diagram (Aho et al., 1972) by pruning transitive relations: . Thus, we can measure both the representativeness and optimality of our selection algorithm. In this experiment, we set and give our selection algorithm a dataset of size to of all possible pairwise orderings. Since there are only possible pairwise relations for , we use a fullyconnected neural network without factorization. Refer to the supplementary for specifics of this network and an algorithm to verify representativeness.
We test the representativeness of our approach against the following baselines: cegis, random x(randomly select x percent of dataset)^{4}^{4}4we use 35% because it matches our average subset size, and hasse (the optimal construction). The measurement of average subset size and fraction of representative subsets is shown in Figure 5. As we can see, our approach selects about twice as many examples as the optimal subset, and 85% of the times our subsets are representative. By contrast, cegis and rand35 fails to discover any representative subset, while rand80 discovers representative subset only 30% of the times despite sampling 80% of the total data. Figure 6 visualizes the chosen pairwise orderings on a particular dataset all. This dataset specifies a unique totalordering, which hasse was able to concisely represent with the minimal representative subset (bottom). our approach also discovers a representative subset, albeit with a few extra redundant relations. By contrast, cegis and rand35 fail to discover a representative subset, as their subsets lack the relationship between elements and , which are adjacent in the total ordering.
6.2 Measuring Improved Synthesis Times
We now measure the performance in terms of on time and stability by using our approach on two distinct tasks.
DFA Synthesis
The task is to synthesize a deterministic finitestate automaton (DFA) from a set of accepted and rejected strings. We use a DSL which contains DFA of states over a binary alphabet of and with a single accept state. The search space of total possible DFAs is of size . 1000 strings of variable length between 5 and 10 were provided as the dataset for each synthesis task, the experiment consists of tasks. On this domain, given a new example string , the neighborhood function selects the top closest prefix and suffix matching examples from the subset
. The neural network architecture is a simple feedforward neural network that predicts the accept/reject label of
directly (see supplementary for parameters details).We measure performance against the following: full (all examples are added), cegis,rand_x (initialize CEGIS with a random fraction of data), h1 (a heuristic that construct a suffixtree over the entire dataset, see supplementary). Figure 7 (top,left) shows the comparison of performances in average time. As we can see, the heuristic subset collection h1 performs best on average, but our approach comes in close (If we disregard the example selection time from NN, the two performs similarly). As we can see, ours, h1, full have similar solve time, which we can infer that our approach and h1 have found a wellconstraining representative subset. This is in stark contrast to cegis which explodes in solve time with hardly any examples chosen. In terms of stability (Figure 7 (bot)), our approach also closely matches that of the heuristic, whereas all other algorithms (except full
) suffers big variance in total time, likely a result of performing synthesis on underrepresentative subsets. Figure
7 (top,right) shows the average number of examples in the collected subset, we see that our approach outperforms randomly selected subsets of any size.Programmatic Drawing Synthesis
We evaluate our approach on 250 randomly sampled 3232 pixel renderings created from the drawing DSL in Section 2, the drawing function has a parameter space of size . The neighborhood function is simply a sliding window centered on each pixel, and is implemented as a convolutional neural network (see supplementary for parameter details).
We measure performance against the following: full (all examples are added), cegis, rcegis, acegis (different CEGIS flavours on how the counter examples are selected: canonical topleft most pixel, random, and a fixed but arbitrary order), rand+cegis (instantiate CEGIS with a random 20% subset), and h1+cegis (a heuristic that adds a pixel if any pixel within a window has a different value). The results are shown in Figure 8. As we can see, our approach performs best on average, beating all competitors on average time. One unexpected outcome is that cegis performs very well on this domain: We postulate that the topleftmost counterexamples chosen by cegis happen to be representative as they tend to lay on the boundaries of the shapes, which is well suited for the drawing DSL domain. However, such coincidence is not to be expected in general: By making the counter example be given at random, or given at a fixed but arbitrary ordering, rcegis and acegis were unable to pick a representative set of examples and suffer in overall time. In terms of variance (Figure 8 (bot)), our approach was able to match the variance of full (clear representative) and h1+cegis (also representative as a sliding window can distinguish squares and lines perfectly). However, our approach was able to discover representative subsets with a much smaller number of examples (Figure 8 (top, right)).
Overall, our approach improves synthesis time and stability by providing CEGIS with a representative subset upfront. ^{5}^{5}5The supplementary material and the code can be found at https://github.com/evanthebouncy/icml2018_selecting_representative_examples
7 Related Work
In recent years there have been an increased interest in program induction. Graves et al. (2014), Reed & De Freitas (2015), Neelakantan et al. (2015) assume a differentiable programming model and learn the operations of the program endtoend using gradient descent. In contrast, in our work we assume a nondifferentiable programming model, allowing us to use expressive program constructs without having to define their differentiable counter parts. Works such as (Reed & De Freitas, 2015) and (Cai et al., 2017) assume strong supervision in the form of complete execution traces, specifying a sequence of exact instructions to execute, while in our work we only assume labeled inputoutput pairs to the program, without any trace information.
Parisotto et al. (2016) and Balog et al. (2016) learn relationships between the inputoutput examples and the structures of the program that generated these examples. When given a set of inputoutputs, these approaches use the learned relationships to prune the search space by restricting the syntactic forms of the candidate programs. In contrast, our committee network learns a relationship between the inputoutput examples, a relationship entirely in the semantic domain. In this sense, these approaches are complimentary.
The predictive task of our neural network is similar to that of (Pu et al., 2017)
, which learns the interrelationships between observations for active learning. In contrast, in our domain the labels to the observations are known in advance. The committee neuralnetwork structure is most similar to the meta programinduction network in
(Devlin et al., 2017). One key difference being we assume a neighborhood function which both limits and orders neighboring inputoutput examples to be encoded. As our subset can grow arbitrarily large, having a hard cap on the number of neighbors is important for efficiency.Acknowledgements
We like to thank the reviewer for their helpful insights; Xin Zhang, Osbert Bastani for constructive criticisms; Steve Mussmann for in depth reference on submodularity; and Twitch Chat for moral supports.
This work was funded by the MUSE program (Darpa grant FA87501420242).
References
 Aho et al. (1972) Aho, A. V., Garey, M. R., and Ullman, J. D. The transitive reduction of a directed graph. SIAM Journal on Computing, 1(2):131–137, 1972. doi: 10.1137/0201008. URL https://doi.org/10.1137/0201008.
 Balog et al. (2016) Balog, M., Gaunt, A. L., Brockschmidt, M., Nowozin, S., and Tarlow, D. Deepcoder: Learning to write programs. arXiv preprint arXiv:1611.01989, 2016.
 Cadar et al. (2008) Cadar, C., Dunbar, D., and Engler, D. R. KLEE: unassisted and automatic generation of highcoverage tests for complex systems programs. In 8th USENIX Symposium on Operating Systems Design and Implementation, OSDI 2008, December 810, 2008, San Diego, California, USA, Proceedings, pp. 209–224, 2008. URL http://www.usenix.org/events/osdi08/tech/full_papers/cadar/cadar.pdf.
 Cai et al. (2017) Cai, J., Shin, R., and Song, D. Making neural programming architectures generalize via recursion. arXiv preprint arXiv:1704.06611, 2017.
 de Moura & Bjørner (2008) de Moura, L. M. and Bjørner, N. Z3: an efficient SMT solver. In Tools and Algorithms for the Construction and Analysis of Systems, 14th International Conference, TACAS 2008, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2008, Budapest, Hungary, March 29April 6, 2008. Proceedings, pp. 337–340, 2008. doi: 10.1007/9783540788003˙24. URL https://doi.org/10.1007/9783540788003_24.
 Devlin et al. (2017) Devlin, J., Bunel, R. R., Singh, R., Hausknecht, M., and Kohli, P. Neural program metainduction. In Advances in Neural Information Processing Systems, pp. 2077–2085, 2017.
 Ellis et al. (2015) Ellis, K., SolarLezama, A., and Tenenbaum, J. B. Unsupervised learning by program synthesis. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 712, 2015, Montreal, Quebec, Canada, pp. 973–981, 2015.
 Ellis et al. (2017) Ellis, K., Ritchie, D., SolarLezama, A., and Tenenbaum, J. B. Learning to infer graphics programs from handdrawn images. arXiv preprint arXiv:1707.09627, 2017.
 Gaunt et al. (2016) Gaunt, A. L., Brockschmidt, M., Singh, R., Kushman, N., Kohli, P., Taylor, J., and Tarlow, D. Terpret: A probabilistic programming language for program induction. CoRR, abs/1608.04428, 2016. URL http://arxiv.org/abs/1608.04428.
 Gent & Walsh (1994) Gent, I. P. and Walsh, T. The sat phase transition. In ECAI, volume 94, pp. 105–109. PITMAN, 1994.
 Gomes et al. (2008) Gomes, C. P., Sabharwal, A., and Selman, B. Model counting, 2008.
 Graves et al. (2014) Graves, A., Wayne, G., and Danihelka, I. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.
 Gulwani et al. (2012) Gulwani, S., Harris, W. R., and Singh, R. Spreadsheet data manipulation using examples. Commun. ACM, 55(8):97–105, 2012. doi: 10.1145/2240236.2240260. URL http://doi.acm.org/10.1145/2240236.2240260.
 Jha et al. (2010) Jha, S., Gulwani, S., Seshia, S. A., and Tiwari, A. Oracleguided componentbased program synthesis. In Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering  Volume 1, ICSE 2010, Cape Town, South Africa, 18 May 2010, pp. 215–224, 2010. doi: 10.1145/1806799.1806833. URL http://doi.acm.org/10.1145/1806799.1806833.
 Neelakantan et al. (2015) Neelakantan, A., Le, Q. V., and Sutskever, I. Neural programmer: Inducing latent programs with gradient descent. arXiv preprint arXiv:1511.04834, 2015.
 Nemhauser et al. (1978) Nemhauser, G. L., Wolsey, L. A., and Fisher, M. L. An analysis of approximations for maximizing submodular set functions—i. Mathematical Programming, 14(1):265–294, 1978.
 Parisotto et al. (2016) Parisotto, E., Mohamed, A.r., Singh, R., Li, L., Zhou, D., and Kohli, P. Neurosymbolic program synthesis. arXiv preprint arXiv:1611.01855, 2016.
 Phothilimthana et al. (2016) Phothilimthana, P. M., Thakur, A., Bodík, R., and Dhurjati, D. Scaling up superoptimization. In Proceedings of the TwentyFirst International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS ’16, Atlanta, GA, USA, April 26, 2016, pp. 297–310, 2016. doi: 10.1145/2872362.2872387. URL http://doi.acm.org/10.1145/2872362.2872387.

Pu et al. (2017)
Pu, Y., Kaelbling, L. P., and SolarLezama, A.
Learning to acquire information.
In
Proceedings of the ThirtyThird Conference on Uncertainty in Artificial Intelligence, UAI 2017, Sydney, Australia, August 1115, 2017
, 2017. URL http://auai.org/uai2017/proceedings/papers/237.pdf.  Reed & De Freitas (2015) Reed, S. and De Freitas, N. Neural programmerinterpreters. arXiv preprint arXiv:1511.06279, 2015.
 Singh & SolarLezama (2016) Singh, R. and SolarLezama, A. SWAPPER: A framework for automatic generation of formula simplifiers based on conditional rewrite rules. In 2016 Formal Methods in ComputerAided Design, FMCAD 2016, Mountain View, CA, USA, October 36, 2016, pp. 185–192, 2016. doi: 10.1109/FMCAD.2016.7886678. URL https://doi.org/10.1109/FMCAD.2016.7886678.
 Singh et al. (2017) Singh, R., Meduri, V., Elmagarmid, A. K., Madden, S., Papotti, P., QuianéRuiz, J., SolarLezama, A., and Tang, N. Generating concise entity matching rules. In Proceedings of the 2017 ACM International Conference on Management of Data, SIGMOD Conference 2017, Chicago, IL, USA, May 1419, 2017, pp. 1635–1638, 2017. doi: 10.1145/3035918.3058739. URL http://doi.acm.org/10.1145/3035918.3058739.
 SolarLezama (2013) SolarLezama, A. Program sketching. STTT, 15(56):475–495, 2013. doi: 10.1007/s1000901202497. URL https://doi.org/10.1007/s1000901202497.
 SolarLezama et al. (2006) SolarLezama, A., Tancau, L., Bodík, R., Seshia, S. A., and Saraswat, V. A. Combinatorial sketching for finite programs. In Proceedings of the 12th International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS 2006, San Jose, CA, USA, October 2125, 2006, pp. 404–415, 2006. doi: 10.1145/1168857.1168907. URL http://doi.acm.org/10.1145/1168857.1168907.
Comments
There are no comments yet.