Resourceful Program Synthesis from Graded Linear Types

Linear types provide a way to constrain programs by specifying that some values must be used exactly once. Recent work on graded modal types augments and refines this notion, enabling fine-grained, quantitative specification of data use in programs. The information provided by graded modal types appears to be useful for type-directed program synthesis, where these additional constraints can be used to prune the search space of candidate programs. We explore one of the major implementation challenges of a synthesis algorithm in this setting: how does the synthesis algorithm efficiently ensure that resource constraints are satisfied throughout program generation? We provide two solutions to this resource management problem, adapting Hodas and Miller’s input-output model of linear context management to a graded modal linear type theory. We evaluate the performance of both approaches via their implementation as a program synthesis tool for the programming language Granule, which provides linear and graded modal typing.


Introduction
Type-directed program synthesis is a long-studied technique rooted in automated theorem proving [29]. A type-directed synthesis algorithm can be constructed as an inversion of type checking, starting from a type and inductively synthesising well-typed subterms, pruning the search space via typing. Via the Curry-Howard correspondence [21], we can view this as proof search in a corresponding logic, where the goal type is a proposition and the synthesised program is its proof. Recent work has extended type-directed synthesis to refinement types [34], cost specifications [27], differential privacy [35], and example-guided synthesis [12,33].
Automated proof search techniques have been previously adapted to linear logics, accounting for resource-sensitive reasoning [7][8][9]20,31]. By removing the structural rules of contraction and weakening, linear logic allows propositions to be treated as resources that must be used exactly once [17]. Non-linear propositions are captured via the 'exponential' modality !. Linearity introduces a new dimension to proof search and program synthesis: how do we inductively generate terms whilst pruning the search space of those which violate linearity? For example, consider the following inductive synthesis rule, mirroring Gentzen's sequent calculus [15], which synthesises a term of type A ⊗ B :

Pair
Reading the rule bottom up: from a context of assumptions Γ 1 , Γ 2 we can synthesise the pair t 1 , t 2 from the product type A⊗B provided that we can inductively synthesise the subterms of the pair, using Γ 1 for the left side and Γ 2 for the right.
But how do we partition a context of free variables Γ into Γ 1 and Γ 2 such that Γ 1 contains only those variables needed by t 1 and Γ 2 only those for t 2 ? A naïve approach is to try every possible partition of Γ . However, this becomes unmanageable as the number of possible partitions is 2 |Γ | , i.e., exponential in the number of assumptions. This issue has been explored in automated theorem proving for linear logic, and is termed the resource management problem [7].
To address this, Hodas and Miller described an input-output context management scheme for linear logic programming [20], further developed by Cervesato et al. [7]. In this approach, synthesis rules take the form Γ A ⇒ t; Δ with an input context Γ and an output context Δ which contains all the hypotheses of Γ that were not used in the proof t of A (akin to the notion of left over typing for linear type systems [2,36]). This output context is then used as the input context to subsequent subgoals. In the case of A ⊗ B , synthesis has the form:

Pair LeftOver
The non-determinism of how to divide Γ is resolved by using the entire context as the input for the synthesis of the first subterm t 1 from type A. If this succeeds, the context Δ 1 is returned containing the resources not needed to construct t 1 . These remaining resources provide the input context to synthesise t 2 from B , which in turn returns an output context Δ 2 containing the resources not used by the pair t 1 , t 2 . We extend this approach, which we term subtractive resource management, to graded modal types and present its dual: additive resource management. In the additive approach, the output context describes what resources were used to synthesise a term, rather than what may still be used.
Graded modal types comprise an indexed family of modal operators whose indices have structure capturing program properties [32]. In the context of linear logic, graded modalities generalise the indexed modality of Bounded Linear Logic [18] ! r A where r ∈ N captures the upper bound r on the number of times A is used. Generalising such indices to an arbitrary (pre-ordered) semiring yields a type system which can be instantiated to track various properties via the graded modality, a technique which is increasingly popular [4,13,14,16,24,25,32,36].
Our primary contribution is the extension of the input-output model of resource management for linear program synthesis to graded modal types. Our input and output contexts contain both linear and graded assumptions. Graded assumptions are annotated with a grade: an element of a pre-ordered semiring describing the variable's use. For example, grades drawn from N yield a system akin to BLL which counts the number of times a variable is used, where a graded assumption x : [A] 2 means x can be used twice. An example instantiation of our subtractive pair introduction rule is then as follows: The initial input context contains graded assumption x : [A] 2 . The first premise synthesises the term x , returning an output context which contains the assumption x with grade 1, indicating that x has been used once and can be used one more time. The next premise synthesises the second part of the pair as x using its remaining use. In the final output context, x is graded by 0, preventing it from being used to synthesise subsequent terms.
We adapt the input-output model of linear logic synthesis to subtractive and additive approaches in the presence of graded modal types, pruning the search space via the quantitative constraints of grades. We develop a type-directed synthesis tool for Granule, a functional language which combines indexed, linear, and graded modal types [32]. Granule supports various graded modalities, and its type checker leverages the Z3 SMT solver to discharge constraints on grades [30]. As type-based synthesis follows the structure of types, it is necessary to solve equations on grades during synthesis, for which we make use of Granule's SMT integration. Such calls to an external prover are costly, and thus efficiency of resource management is a key concern. Section 2 introduces our core type theory (a subset of Granule's type system) based on the linear λ-calculus extended with graded modal types, pairs, and sums. Section 3 describes the two core synthesis calculi (subtractive and additive) as augmented inversions of the typing rules, as well as a variant of additive synthesis. Section 4 describes the implementation 1 and gives a quantitative comparison of the synthesis techniques on a suite of benchmark programs. The main finding is that the additive approach is often more efficient than the subtractive, presenting a departure from the literature on linear logic theorem proving which is typically subtractive.
Throughout, we will mostly use types-and-programs terminology rather than propositions-and-proofs. Through the Curry-Howard correspondence, one can switch smoothly to viewing our approach as proof search in logic.

Graded Linear λ-calculus
Our focus is a linear λ-calculus akin to a simply-typed linear functional language with graded modalities, resembling the core languages of Gaboardi et al. [14] and Brunel et al. [4], and a simply-typed subset of Granule [32].
Types comprise linear functions, multiplicative conjunction (product types ⊗ and unit 1), additive disjunction (sum types ⊕), and a graded modality r : where r A is an indexed family of type operators where r ranges over the elements of some pre-ordered semiring (R, * , 1, +, 0, ) parameterising the calculus (where * and + are monotonic with respect to the pre-order ). The syntax of terms provides the elimination and introduction forms: We use the syntax () for the inhabitant of multiplicative unit 1. Pattern matching via a let is used to eliminate products and unit types; for sum types, case is used to distinguish the constructors. The construct [t] introduces a graded modal type r A by 'promoting' a term t to the graded modality, and let [x ] = t 1 in t 2 eliminates a graded modal value t 1 , binding a graded variable x in scope of t 2 .
Typing judgments are of the form Γ t : A, where Γ ranges over contexts: Thus, a context may be empty ∅, extended with a linear assumption x : A or extended with a graded assumption x : [A] r . For linear assumptions, structural rules of weakening and contraction are disallowed. Graded assumptions may be used non-linearly according to the constraints given by their grade, the semiring element r. Throughout, comma denotes disjoint context concatenation. Various operations on contexts are used to capture non-linear data flow via grading. Firstly, context addition provides an analogue to contraction, combining contexts that have come from typing multiple subterms in a rule. Context addition, written Γ 1 +Γ 2 , is undefined if Γ 1 and Γ 2 overlap in their linear assumptions. Otherwise graded assumptions appearing in both contexts are combined via the semiring + of their grades.

Definition 1 (Context addition).
For all Γ 1 , Γ 2 context addition is defined as follows by ordered cases matching inductively on the structure of Γ 2 : In the typing of case expressions, the least-upper bound of the two contexts used to type each branch is used, defined:

Definition 2 (Partial least-upper bounds of contexts).
For all Γ 1 , Γ 2 : where r s is the least-upper bound of grades r and s if it exists, derived from .
As an example of the partiality of , if one branch of a case uses a linear variable, then the other branch must also use it to maintain linearity overall, otherwise the upper-bound of the two contexts for these branches is not defined.  Figure 1 defines the typing rules. Linear variables are typed in a singleton context (Var). Abstraction (Abs) and application (App) follow the rules of the linear λ-calculus. Rules for multiplicative products (pairs) and additive coproducts (sums) are routine, where pair introduction (Pair) adds the contexts used to type the pair's constituent subterms. Pair elimination (LetPair) binds a pair's components to two linear variables in the scope of the body t 2 . The Inl and Inr rules handle the typing of constructors for the sum type A⊕B . Elimination of sums (Case) takes the least upper bound (defined above) of the contexts used to type the two branches of the case.
The Weak rule captures weakening of assumptions graded by 0 (where [Δ] 0 denotes a context containing only graded assumptions graded by 0). Dereliction (Der), allows a linear assumption to be converted to a graded assumption with grade 1. Grade approximation is captured by the Approx rule, which allows a grade r to be converted to another grade s, providing that r is approximated by s, where the relation is the pre-order provided with the semiring. Introduction and elimination of the graded modality is provided by the Pr and Let rules respectively. The Pr rule propagates the grade r to the assumptions through scalar multiplication of Γ by r where every assumption in Γ must already be graded (written [Γ ] in the rule), defined:

Definition 3 (Scalar context multiplication)
The Let rule eliminates a graded modal value r A into a graded assumption x : [A] r with a matching grade in the scope of the let body. We now give three examples of different graded modalities.
Example 1. The natural number semiring with discrete ordering (N, * , 1, +, 0, ≡) provides a graded modality that counts exactly how many times non-linear values are used. As a simple example, the S combinator is typed and defined: The graded modal value z captures the 'capability' for a value of type A to be used twice. This capability is made available by eliminating (via let) to the variable z, which is graded z : [A] 2 in the scope of the body.

Example 2.
Exact usage analysis is less useful when control-flow is involved, e.g., eliminating sum types where each control-flow branch uses variables differently. The above N-semiring can be imbued with a notion of approximation via lessthan-equal ordering, providing upper bounds. A more expressive semiring is that of natural number intervals [32] where ∞ is absorbing for all operations, except multiplying by 0.
Example 3. Graded modalities can capture a form of information-flow security, tracking the flow of labelled data through a program [32], with a lattice-based semiring on R = {Unused Hi Lo} where 0 = Unused, 1 = Hi, + = and if r = Unused or s = Unused then r * s = Unused otherwise r * s = . This allows the following well-typed program, eliminating a pair of Lo and Hi security values, picking the left one to pass to a continuation expecting a Lo input: Metatheory. The admissibility of substitution is a key result that holds for this language [32], which is leveraged in soundness of the synthesis calculi.

The Synthesis Calculi
We present two synthesis calculi with subtractive and additive resource management schemes, extending an input-output approach to graded modal types. The structure of the synthesis calculi mirrors a cut-free sequent calculus, with left and right rules for each type constructor. Right rules synthesise an introduction form for the goal type. Left rules eliminate (deconstruct) assumptions so that they may be used inductively to synthesise subterms.

Subtractive Resource Management
Our subtractive approach follows the philosophy of earlier work on linear logic proof search [7,20], structuring synthesis rules around an input context of the available resources and an output context of the remaining resources that can be used to synthesise subsequent subterms. Synthesis rules are read bottom-up, with judgments Γ A ⇒ − t; Δ meaning from the goal type A we can synthesise a term t using assumptions in Γ , with output context Δ. We describe the rules in turn to aid understanding. The appendix [22] collects the rules for reference. Variable terms can be synthesised from linear or graded assumptions by rules: On the left, a variable x may be synthesised for the goal A if a linear assumption x : A is present in the input context. The input context without x is then returned as the output context, since x has been used. On the right, we can synthesise a variable x for A we have a graded assumption of x matching the type. However, the grading r must permit x to be used once here. Therefore, the premise states that there exists some grade s such that grade r approximates s + 1. The grade s represents the use of x in the rest of the synthesised term, and In typing, λ-abstraction binds linear variables to introduce linear functions. Synthesis from a linear function type therefore mirrors typing: Thus, λx.t can be synthesised given that t can be synthesised from B in the context of Γ extended with a fresh linear assumption x : A. To ensure that x is used linearly by t we must therefore check that it is not present in Δ.
The left-rule for linear function types then synthesises applications (as in [20]): The rule synthesises a term for type C in a context that contains an assumption x 1 : A B . The first premise synthesises a term t 1 for C under the context extended with a fresh linear assumption x 2 : B , i.e., assuming the result of x 1 . This produces an output context Δ 1 that must not contain x 2 , i.e., x 2 is used by t 1 . The remaining assumptions Δ 1 provide the input context to synthesise t 2 of type A: the argument to the function x 1 . In the conclusion, the application x 1 t 2 is substituted for x 2 inside t 1 , and Δ 2 is the output context.
Note that this rule synthesises the application of a function given by a linear assumption. What if we have a graded assumption of function type? Rather than duplicating every left rule for both linear and graded assumptions, we mirror the dereliction typing rule (converting a linear assumption to graded) as: Dereliction captures the ability to reuse a graded assumption being considered in a left rule. A fresh linear assumption y is generated that represents the graded assumption's use in a left rule, and must be used linearly in the subsequent synthesis of t. The output context of this premise then contains x graded by s , which reflects how x was used in the synthesis of t, i.e. if x was not used then s = s. The premise ∃s. r s + 1 constrains the number of times dereliction can be applied so that it does not exceed x's original grade r.
For a graded modal goal type r A, we synthesise a promotion [t] if we can synthesise the 'unpromoted' t from A: Recall that typing of a promotion [t] scales all the graded assumptions used to type t by r. Therefore, to compute the output context we must "subtract" r-times the use of the variables in t. However, in the subtractive model Δ tells us what is left, rather than what is used. Thus we first compute the context subtraction of Γ and Δ yielding the variables usage information about t:

Definition 4 (Context subtraction).
For all Γ 1 , Γ 2 where Γ 2 ⊆ Γ 1 : As in graded variable synthesis, context subtraction existentially quantifies a variable q to express the relationship between grades on the right being "subtracted" from those on the left. The last conjunct states q is the greatest element (wrt. to the pre-order) satisfying this constraint, i.e., for all other q ∈ R satisfying the subtraction constraint then q q e.g., if r = [2.. Thus for R − , Γ − Δ is multiplied by the goal type grade r to obtain how these variables are used in t after promotion. This is then subtracted from the original input context Γ giving an output context containing the left-over variables and grades. Context multiplication requires that Γ −Δ contains only graded variables, preventing the incorrect use of linear variables from Γ in t.
Synthesis of graded modality elimination, is handled by the L − left rule: Given an input context comprising Γ and a linear assumption x 1 of graded modal type, we can synthesise an unboxing of x 1 if we can synthesise a term t under Γ extended with a graded assumption x 2 : [A] r . This returns an output context that must contain x 2 graded by s with the constraint that s must approximate 0. This enforces that x 2 has been used as much as required by the grade r.
The right and left rules for products, units, and sums, are then fairly straightforward following the subtractive resource model: The L⊕ − rule synthesises the left and right branches of a case statement that may use resources differently. The output context therefore takes the greatest lower bound ( ) of Δ 1 and Δ 2 . We elide definition of context as it has the same shape as for contexts (Definition 2), just replacing with on grades.
As an example of , consider the semiring of intervals over natural numbers and two judgements that could be used as premises for the (L⊕ − ) rule: where t 1 uses y such that there are 2-5 uses remaining and t 2 uses y such that there are 3-4 uses left. To synthesise case x 1 of inl x 2 → t 1 | inr x 3 → t 2 the output context must be pessimistic about what resources are left, thus we take the greatest-lower bound yielding the interval [2 . . . 4] here: we know y can be used at least twice and at most 4 times in the rest of the synthesised program.
This completes subtractive synthesis. We conclude with a key result, that synthesised terms are well-typed at the type from which they were synthesised:

Lemma 2. (Subtractive synthesis soundness). For all Γ and A then:
i.e. t has type A under context Γ − Δ, that contains just those linear and graded variables with grades reflecting their use in t. The appendix [22] provides the proof.

Additive Resource Management
We now propose a dual additive resource management approach. Additive synthesis also uses the input-output context approach, but where output contexts describe exactly which assumptions were used to synthesise a term, rather than which assumptions are still available. Additive synthesis rules are read bottomup, with Γ A ⇒ + t; Δ meaning that from the type A we synthesise a term t using exactly the assumptions Δ that originate from the input context Γ . We unpack the rules, starting with variables: GrVar + For a linear assumption, the output context contains just the variable that was synthesised. For a graded assumption x : [A] r , the output context contains the assumption graded by 1. To synthesise a variable from a graded assumption, we must check that the use is compatible with the grade. The subtractive approach handled this rule (GrVar − ) by a constraint ∃s. r s + 1. Here however, the point at which we check that a graded assumption has been used according to the grade takes place in the L + rule, where graded assumptions are bound: Here, t is synthesised under a fresh graded assumption x 2 : [A] r . This produces an output context containing x 2 with some grade s that describes how x 2 is used in t. An additional premise requires that the original grade r approximates either s if x 2 appears in Δ or 0 if it does not, ensuring that x 2 has been used correctly. For the N-semiring with equality as the ordering, this would ensure that a variable has been used exactly the number of times specified by the grade.
Right and left rules for have a similar shape to the subtractive calculus: Synthesising an abstraction (R + ) requires that x : A is in the output context of the premise, ensuring that linearity is preserved. Likewise for application (L + ), the output context of the first premise must contain the linearly bound x 2 : B and the final output context must contain the assumption being used in the application x 1 : A B . This output context computes the context addition (Definition 1) of both output contexts of the premises Δ 1 + Δ 2 . If Δ 1 describes how assumptions were used in t 1 and Δ 2 respectively for t 2 , then the addition of these two contexts describes the usage of assumptions for the entire subprogram.
Recall, context addition ensures that a linear assumption may not appear in both Δ 1 and Δ 2 , preventing us from synthesising terms that violate linearity.
As in the subtractive calculus, we avoid duplicating left rules to match graded assumptions by giving a synthesising version of dereliction: The fresh linear assumption y : A must appear in the output context of the premise, ensuring it is used. The final context therefore adds to Δ an assumption of x graded by 1, accounting for this use of x (temporarily renamed to y).
Synthesis of a promotion is considerably simpler in the additive approach. In subtractive resource management it was necessary to calculate how resources were used in the synthesis of t before then applying the scalar context multiplication by the grade r and subtracting this from the original input Γ . In additive resource management, however, we can simply apply the multiplication directly to the output context Δ to obtain how our assumptions are used in [t]: As in the subtractive approach, the right and left rules for products, units, and sums follow fairly straightforwardly from the resource scheme: Rule (L⊕ + ) takes the least-upper bound of the premise's output contexts (Definition 2).

Lemma 3. (Additive synthesis soundness). For all Γ and A:
The appendix [22] provides the proof.
2. For complex problems, additive synthesis will explore more paths as it cannot tell whether a variable is not well-resourced until closing a binder; additive pruning and subtractive will explore fewer paths as they can fail sooner. 3. A corollary of the above two: simple examples will likely be faster in additive mode, but more complex examples will be faster in subtractive mode.
Methodology. We implemented our approach as a synthesis tool for Granule, integrated with its core tool. Granule features ML-style polymorphism (rank-0 quantification) but we do not address polymorphism here. Instead, programs are synthesised from type schemes treating universal type variables as logical atoms.
We discuss additional details of the implementation at the end of this section.
To evaluate our synthesis tool we developed a suite of benchmarks comprising Granule type schemes for a variety of operations using linear and graded modal types. We divide our benchmarks into several classes of problem: -Hilbert: the Hilbert-style axioms of intuitionistic logic (including SKI combinators), with appropriate N and N-interval grades where needed (see, e.g., S combinator in Example 1 or coproduct elimination in Example 2). -Comp: various translations of function composition into linear logic: multiplicative, call-by-value and call-by-name using ! [17], I/O using ! [28], and coKleisli composition over N and arbitrary semirings: e.g. ∀r, s ∈ R: -Dist: distributive laws of various graded modalities over functions, sums, and products [23], e.g., ∀r ∈ N, or ∀r ∈ R in any semiring, or r = [0...∞]: -Vec: map operations on vectors of fixed size encoded as products, e.g.: -Misc: includes Example 3 (information-flow security) and functions which must share or split resources between graded modalities, e.g.: The appendix [22] lists the type schemes for these synthesis problems (32 in total). We found that Z3 is highly variable in its solving time, so timing measurements are computed as the mean of 20 trials. We used Z3 version 4.8.8 on a Linux laptop with an Intel i7-8665u @ 4.8 Ghz and 16 Gb of RAM. Results and Analysis. For each synthesis problem, we recorded whether synthesis was successful or not (denoted or ×), the mean total synthesis time (μT ), the mean total time spent by the SMT solver (μsmt), and the number of calls made to the SMT solver (N). Table 1 summarises the results with the fastest case for each benchmark highlighted. For all benchmarks that used the SMT solver, the solver accounted for 91.73%-99.98% of synthesis time, so we report only the mean total synthesis time μT . We set a timeout of 120 s. Additive vs. Subtractive. As expected, the additive approach generally synthesises programs faster than the subtractive. Our first hypothesis (that the additive approach in general makes fewer calls to the SMT solver) holds for almost all benchmarks, with the subtractive approach often far exceeding the number made by the additive. This is explained by the difference in graded variable synthesis between approaches. In the additive, a constant grade 1 is given for graded assumptions in the output context, whereas in the subtractive, a fresh grade variable is created with a constraint on its usage which is checked immediately. As the total synthesis time is almost entirely spent in the SMT solver (more than 90%), solving constraints is by far the most costly part of synthesis leading to the additive approach synthesising most examples in a shorter amount of time.
Graded variable synthesis in the subtractive case also results in several examples failing to synthesise. In some cases, e.g., the first three comp benchmarks, the subtractive approach times-out as synthesis diverges with constraints growing in size due to the maximality condition and absorbing behaviour of [0...∞] interval. In the case of coK-R and coK-N, the generated constraints have the form ∀r.∃s.r s + 1 which is not valid ∀r ∈ N (e.g., when r = 0), which suggests that the subtractive approach does not work well for polymorphic grades. As further work, we are considering an alternate rule for synthesising promotion with constraints of the form ∃s.s = s * r, i.e., a multiplicative inverse constraint.
In more complex examples we see evidence to support our second hypothesis. The share problem requires a lot of graded variable synthesis which is problematic for the additive approach, for the reasons described in the second hypothesis. In contrast, the subtractive approach performs better, with μT = 190.07 ms as opposed to additive's 268.95 ms. However, additive pruning outperforms both.
Additive Pruning. The pruning variant of additive synthesis (where subtraction takes place in the premises of multiplicative rules) had mixed results compared to the default. In simpler examples, the overhead of pruning (requiring SMT solving) outweighs the benefits obtained from reducing the space. However, in more complex examples which involve synthesising many graded variables (e.g. share), pruning is especially powerful, performing better than the subtractive approach. However, additive pruning failed to synthesis two examples which are polymorphic in their grade (⊗-N) and in the semiring/graded-modality (⊗-R).
Overall, the additive approach outperforms the subtractive and is successful at synthesising more examples, including ones polymorphic in grades and even the semiring itself. Given that the literature on linear logic theorem proving is typically subtractive, this is an interesting result. Going forward, a mixed approach between additive and additive pruning may be possible, selecting the algorithm, or even the rules, depending on the class of problem. Exploring this, and further optimisations and improvements, is further work.
Additional Implementation Details. Constraints on resource usage are handled via Granule's existing symbolic engine, which compiles constraints on grades (for various semirings) to the SMT-lib format for Z3 [30]. We use the LogicT monad for backtracking search [26] and the Scrap Your Reprinter library for splicing synthesised code into syntactic "holes", preserving the rest of the program text [10]. The implementation of the rule for additive dereliction (der + ) requires some care. A naïve implementation of this rule would allow the construction of an infinite chain of dereliction applications, by repeatedly applying the rule to the same graded assumption, as the correct usage of the assumption's grade is only verified after it has been used to synthesise a sub-term. Our solution is to simply disallow immediate consecutive applications of the dereliction rule in additive synthesis, requiring that another rule be applied between multiple applications of the dereliction rule to any assumption. If no other rules can be applied, then the branch of synthesis is terminated.

Discussion
Further Related Work. Before Hodas and Miller [20], the problem of resource non-determinism was first identified by Harland and Pym [19]. Their solution delays splitting of contexts at a multiplicative connective. They later explored the implementation details of this approach, proposing a solution where proof search is formulated in terms of constraints on propositions. The logic programming language Lygon [1] implements this approach.
Our approach to synthesis implements a backward style of proof search: starting from the goal, recursively search for solutions to subgoals. In contrast to this, forward reasoning approaches attempt to reach the goal by building subgoals from previously proved subgoals until the overall goal is proved. Pfenning and Chaudhuri consider forward approaches to proof search in linear logic using the inverse method [11] where the issue of resource non-determinism that is typical to backward approaches is absent [8,9].
Non-idempotent intersection types systems have a similar core structure resembling the linear λ-calculus with quantitative aspects akin to grading [6]. It therefore seems likely that the approaches of this paper could be applied in this setting and used, for example, as way to enhance or even improve existing work on the inhabitation problem for non-idempotent intersection types [5]: a synthesised term gives a proof of inhabitation. This is left as further work, including formalising the connection between non-idempotent intersections and grading.
Next Steps and Conclusions. Our synthesis algorithms are now part of the Granule toolchain with IDE support, allowing programmers to insert a "hole" in a term and, after executing a keyboard shortcut, Granule tries to synthesise the type of the hole, pretty-printing generated code and inserting it at the cursor.
There are various extensions which we are actively pursuing, including synthesis for arbitrary user-defined indexed data types (GADTs), polymorphism, and synthesis of recursive functions. We plan to study various optimisations to the approaches considered here, as well as reducing the overhead of starting the SMT solver each time by instead running an "online" SMT solving procedure. We also plan to evaluate the approach on the extended linear logical benchmarks of Olarte et al. [31]. Although our goal is to create a practical program synthesis tool for common programming tasks rather than a general purpose proof search tool, the approach here also has applications to automated theorem proving.