Recursive Function Synthesis

• Recursive function synthesis is the automated generation of recursively defined programs or program families from examples, logical properties, sketches, or templates.
• It tackles challenges in representing and verifying hidden recursive structures by employing methods such as unrolling, angelic execution, and recursion schemes.
• Various approaches, including type-directed synthesis and inductive decomposition, improve efficiency and ensure correctness in the synthesis of complex recursive programs.

Searching arXiv for recent and foundational papers on recursive function synthesis to ground the article. Recursive function synthesis is the automatic construction of recursively defined programs, loop-like functions, or size-parametric program families from examples, logical properties, sketches, templates, or resource specifications. In the literature considered here, it appears in several distinct but technically related forms: synthesis in SyGuS and programming-by-example, synthesis from relational specifications over unbounded domains, sketch-based synthesis from mixed-quantifier properties, type-directed synthesis under symbolic or asymptotic resource bounds, synthesis of recursive ADT transformations from reusable templates, bottom-up recursive synthesis via angelic execution, recursive query optimization by synthesizing a new recursive update, recursive quantum unitary-program synthesis, and visual-to-symbolic fractal program synthesis (Berman et al., 2021, Kneuss et al., 2013, Egolf et al., 7 Jan 2026, Knoth et al., 2019, Deng et al., 2023, Ondras et al., 9 Nov 2025).

1. Problem formulations and conceptual scope

A central distinction in this area is between recursive synthesis as a first-class target and synthesis methods that remain fundamentally recursion-free. In SyGuS, recursion is allowed by the standard, but the cited work emphasizes that “no existing SyGuS solvers have support for synthesizing recursive functions,” even though such solvers are often effective on straight-line, loop-free ASTs (Berman et al., 2021). In deductive synthesis over algebraic data types, the target is a recursive functional program over unbounded domains, typically specified by a relational postcondition rather than by examples (Kneuss et al., 2013). In sketch-based work on mixed-quantifier properties, the target is again recursive, but the search space is explicitly constrained by multi-sketches and measure functions (Egolf et al., 7 Jan 2026).

The term also covers settings in which the synthesized object is not a single fixed-size function instance. QSynth targets recursively defined families of quantum unitary circuits indexed by input size $n$, so correctness is required for an entire family $\{S(n)\}_{n\in\mathbb N}$, not just one circuit (Deng et al., 2023). Recursive Cartan decompositions factorize $N$-qubit unitaries through a nested chain of symmetric-space decompositions; this is unitary synthesis rather than recursive functional synthesis in the usual ADT or ML-like sense, but it is explicitly recursive at the decomposition level and is used as an overview pipeline for exact circuit construction (Wierichs et al., 24 Mar 2025). FractalBench pushes the notion into visual-mathematical reasoning: a model sees an image of a fractal and must recover the recursive generative program that produced it (Ondras et al., 9 Nov 2025).

An important boundary case is explicit in the literature. “Synthesiz3 This” addresses “single-invocation recursion-free functions” and “does not present a general technique for synthesizing truly recursive functions” (Hozzová et al., 23 Apr 2025). This matters because it clarifies that recursive function synthesis is not merely synthesis in the presence of recursion elsewhere in the specification language; it is synthesis of recursive definitions, recursive schemes, or recursive program families.

2. Specification modalities

The most direct formulation is programming-by-example. In the SyGuS/PBE setting, the goal is to synthesize $f(x)$ such that

$\forall ex_i \in C,\quad f(in_i)=out_i.$

The difficulty, as emphasized in the looping-program work, is that examples expose outputs but do not make a shared recurrence explicit; the examples must be interpreted as “unrolled” recursive behaviors (Berman et al., 2021).

A second formulation uses relational specifications over unbounded domains. Leon represents synthesis problems as quadruples $\langle \seqa, \pcname, \phi, \seqx \rangle$, with correctness conditions given by relation refinement and domain preservation. This supports recursive programs over lists, unary naturals, and integers, where specifications may involve abstraction functions such as value, content, size, or isSorted (Kneuss et al., 2013). Closely related work on ADT transformations uses semantic equivalence assertions such as

$$\texttt{srcInterpret(exp) == dstInterpret(desugar(exp))},$$

which turns recursive synthesis into transformation synthesis under an interpreter-based specification (Inala et al., 2015).

A third formulation centers on mixed-quantifier properties. The Cataclyst framework studies benchmarks such as

$$\forall xs, ys.\; \text{prefixb}(xs, ys) \implies \exists suffix.\; ys = xs \cdot suffix,$$

and reduces such properties to $\forall^*$-synthesis by Skolemization, treating the introduced Skolem symbols as additional witness-generating functions under synthesis (Egolf et al., 7 Jan 2026). This is significant because many natural recursive-program properties are not purely universal.

A fourth formulation integrates resource bounds into the specification itself. ReSyn combines functional specifications and symbolic resource bounds using a type system that extends refinement types with potential annotations (Knoth et al., 2019). SynPlexity goes further by letting the user specify asymptotic bounds directly in big-$O$ form using annotated types $\{S(n)\}_{n\in\mathbb N}$0, where recurrence templates justified by the Master Theorem and the Akra–Bazzi method are encoded into the typing discipline (Hu et al., 2021). In the quantum setting, QSynth-spec uses a hypothesis-amplitude specification: $\{S(n)\}_{n\in\mathbb N}$1 which replaces matrix-sized predicates with a more synthesis-friendly input-output form for recursive unitary programs (Deng et al., 2023).

FractalBench introduces a qualitatively different specification regime. The target is executable Python code that reproduces a fractal image, and correctness is judged by Intersection over Union on binary masks,

$\{S(n)\}_{n\in\mathbb N}$2

with success requiring both successful execution and IoU at least $\{S(n)\}_{n\in\mathbb N}$3 (Ondras et al., 9 Nov 2025). This suggests a specification interface in which recursive synthesis is mediated by perception rather than textual formulas or examples.

3. Search strategies and synthesis biases

One major line of work avoids direct search over arbitrary recursive syntax and instead reconstructs recursion from non-recursive artifacts. The SyGuS looping-program method is a five-phase procedure: split constraints, solve each subset with an ordinary solver, detect “loopable” repeated structure, synthesize the loop condition, and stitch the recursive program (Berman et al., 2021). Its central move is to treat per-example solutions as unrolled recursive instances and recover a common recursive core by repeated contiguous subtree detection.

A different line is bottom-up synthesis with angelic execution. Burst addresses the problem that a bottom-up synthesizer cannot concretely execute a recursive call in a program that has not yet been fully constructed. It therefore gives recursive calls an angelic semantics, allowing them to return any value consistent with the current specification; accepting runs are then analyzed to extract a witness of the assumptions made, the specification is strengthened, and synthesis is retried (Miltner et al., 2021). The underlying representation is a version space encoded by finite tree automata, which supports repeated incremental synthesis calls.

A third line imposes a strong structural bias through recursion schemes. Origami does not search over arbitrary recursion but over a small family of templates such as catamorphism, anamorphism, accumulation, and hylomorphism. The recursive skeleton is fixed, and GP evolves only the typed slots inside the pattern (Fernandes et al., 2024). The reusable-template approach in SyntRec follows a similar philosophy in a symbolic-template setting: polymorphic synthesis constructs such as case?, e.fields?, and new cons?(...) allow a generic library component like recursiveReplacer to expand into a specialized recursive template for a given pair of ADTs (Inala et al., 2015).

Search can also be constrained by sketches and counterexample structure. Cataclyst uses lazy enumerative search over sketch completions, with counterexample generalization producing syntactic pruning constraints, and prophylactic pruning rejecting partial hole fillings before they form complete candidates (Egolf et al., 7 Jan 2026). Leon combines validated deductive synthesis rules, symbolic term exploration, and condition abduction, producing recursive programs by constructing and verifying recursive schemas rather than by brute-force recursive enumeration (Kneuss et al., 2013).

Across these approaches, a recurring theme is that raw recursion is seldom searched for directly. The literature instead introduces intermediate bias: repeated-AST detection, angelic semantics, recursion schemes, reusable templates, sketches, or deductive schemas. This suggests that the practical difficulty lies not only in verification of recursion but in representing the recursive search space in a form that is both finite enough for automation and expressive enough to capture the intended solution.

4. Typing, verification, and recurrence reasoning

Verification infrastructure is often the decisive component in recursive synthesis. Leon integrates synthesis with a verifier based on satisfiability modulo recursive functions, alternating over- and under-approximations of recursive executions while delegating checks to Z3 (Kneuss et al., 2013). This allows synthesis from relational specifications over unbounded domains, with correctness established by validated inference rules and subsequent recursive-function reasoning.

Resource-aware systems make verification part of the search bias itself. ReSyn’s type system Re combines polymorphic refinement types with potential annotations from automatic amortized resource analysis. A type $\{S(n)\}_{n\in\mathbb N}$4 denotes a refinement type $\{S(n)\}_{n\in\mathbb N}$5 carrying potential $\{S(n)\}_{n\in\mathbb N}$6, and subtyping requires the source potential to dominate the target potential (Knoth et al., 2019). This permits eager rejection of incomplete recursive programs that cannot possibly satisfy the resource budget. SynPlexity replaces exact symbolic costs with asymptotic annotations of the form

$\{S(n)\}_{n\in\mathbb N}$7

so the type system can track recursive call counts and subproblem sizes, derive recurrences such as $\{S(n)\}_{n\in\mathbb N}$8, and discharge the asymptotic claim using theorem templates such as the Master Theorem and Akra–Bazzi (Hu et al., 2021).

Quantum recursive synthesis requires a different verification architecture because the semantics vary with circuit size and involve complex amplitudes. QSynth addresses this by combining an inductive language, a Hoare-like logic over hypothesis-amplitude specifications, and an SMT encoding based on Parameterized Path-Sum Amplitudes. The Fix rule verifies base cases and recursive cases by relating the target specification to the composition of left context, relabeled predecessor, and right context (Deng et al., 2023). The encoding relies on sparsity so that recursive composition does not yield an intractable infinite sum.

In recursive ADT transformation synthesis, the verification burden can sometimes be reduced by exploiting the specification’s own inductive structure. SyntRec’s inductive decomposition replaces a recursive call on a smaller subterm with a placeholder and, when that placeholder appears inside the target interpreter, rewrites it directly using the source interpreter. The paper states that inductive decomposition is sound and complete, and this effectively makes some recursive transformations non-recursive during bounded synthesis (Inala et al., 2015).

These systems differ substantially in formal apparatus, but they share a common pattern: recursive synthesis becomes tractable when verification can reconstruct, bound, or abstract the recursive effect. In one case the abstraction is potential, in another it is a recurrence template, in another a sparse amplitude representation, and in another an inductive interpreter equivalence.

5. Domains and representative tasks

The domain range is unusually broad. In SyGuS/PBE, the focus is on loop-like string-manipulation programs. The motivating example repeats a string according to its length, and the intended recursive solution is expressed with a helper $\{S(n)\}_{n\in\mathbb N}$9 and a counter $N$0 (Berman et al., 2021). In tree-to-string synthesis, the goal is to learn structurally recursive pretty printers and serializers, formalized as deterministic sequential top-down tree-to-string transducers with one state, whose semantics on $N$1 is

$N$2

for constructor-specific string constants $N$3 (Mayer et al., 2017).

Recursive functional synthesis over ADTs includes arithmetic on unary naturals, list splitting, insertion into sorted lists, insertion sort, merge sort, and other list-manipulation tasks (Kneuss et al., 2013). Template-based recursive ADT transformation synthesis includes desugaring between source and destination ASTs, lambda-calculus encodings, and type-constraint generation (Inala et al., 2015). Origami evaluates folds, unfolds, accumulated folds, and hylomorphisms on the 29 tasks of General Program Synthesis Benchmark Suite 1, explicitly treating recursion-scheme choice as an overview bias (Fernandes et al., 2024).

Recursive synthesis also appears in data systems. The FGH-rule reframes recursive query optimization as synthesis of a new recursive update $N$4 satisfying

$N$5

This subsumes examples such as connected components, magic sets, and semi-naive evaluation in recursive Datalog-style settings (Wang et al., 2022). In the quantum domain, QSynth synthesizes recursive variants of GHZ preparation, arithmetic circuits, QFT, eigenvalue inversion for HHL, and teleportation, producing programs that can be transpiled to Q#, Qiskit, and Braket (Deng et al., 2023). Recursive Cartan decompositions similarly support exact unitary synthesis through chains such as

$N$6

(Wierichs et al., 24 Mar 2025).

FractalBench extends the domain to image-conditioned recursive program induction. Fractals are defined through Iterated Function Systems, with attractor equation

$N$7

and the synthesis target is Python code over a minimal drawing API that reproduces the observed self-similar structure (Ondras et al., 9 Nov 2025). This reframes recursive synthesis as abstraction from finite visual evidence to a compact self-referential rule.

6. Complexity results, empirical performance, and limitations

Several papers establish formal complexity boundaries. For tree-to-string functions, checking whether there exists a consistent 1STS for an arbitrary sample is NP-complete, but the problem becomes polynomial-time under the closure condition that every subtree of a tree in the sample is also part of the sample; the active-learning version asks at most $N$8 queries, more precisely at most $N$9 (Mayer et al., 2017). In recursive query optimization, the FGH-rule can yield speedups up to 4 orders of magnitude on three already optimized Datalog systems (Wang et al., 2022). In recursive Cartan decomposition, the transverse-field XY model on $f(x)$0 qubits is compiled into $f(x)$1 gates in 22 seconds on a laptop (Wierichs et al., 24 Mar 2025).

Benchmark results show that the choice of bias and verification method strongly affects practical solvability. The SyGuS looping-program wrapper solves three string-manipulation PBE SyGuS benchmarks with times $f(x)$2s, $f(x)$3s, and $f(x)$4s and AST sizes $f(x)$5, $f(x)$6, and $f(x)$7; standalone CVC4 times out on two and yields AST size $f(x)$8 on the third (Berman et al., 2021). Burst solves $f(x)$9 IO benchmarks, $\forall ex_i \in C,\quad f(in_i)=out_i.$0 reference-implementation benchmarks, and $\forall ex_i \in C,\quad f(in_i)=out_i.$1 logical-specification benchmarks, corresponding to $\forall ex_i \in C,\quad f(in_i)=out_i.$2, $\forall ex_i \in C,\quad f(in_i)=out_i.$3, and $\forall ex_i \in C,\quad f(in_i)=out_i.$4 respectively (Miltner et al., 2021). Cataclyst’s prophylactic-pruning variant solves $\forall ex_i \in C,\quad f(in_i)=out_i.$5 benchmarks at a 15-minute timeout, compared with $\forall ex_i \in C,\quad f(in_i)=out_i.$6 for retrospective pruning and $\forall ex_i \in C,\quad f(in_i)=out_i.$7 without generalization (Egolf et al., 7 Jan 2026). Origami, evaluated on all 29 PSB1 tasks, improves over HOTGP in the number of best results and reports strong success on tasks such as scrabble-score $\forall ex_i \in C,\quad f(in_i)=out_i.$8, grade $\forall ex_i \in C,\quad f(in_i)=out_i.$9, mirror-image $\langle \seqa, \pcname, \phi, \seqx \rangle$0, and for-loop-index $\langle \seqa, \pcname, \phi, \seqx \rangle$1 (Fernandes et al., 2024).

Resource-aware and asymptotic-type systems target a different performance axis. ReSyn synthesizes programs that are asymptotically more efficient than those generated by a resource-agnostic synthesizer and is faster than a naive combination of synthesis and resource analysis; it also supports constant-resource implementations for fixed input sizes (Knoth et al., 2019). SynPlexity synthesizes divide-and-conquer programs with bounds such as $\langle \seqa, \pcname, \phi, \seqx \rangle$2, $\langle \seqa, \pcname, \phi, \seqx \rangle$3, and $\langle \seqa, \pcname, \phi, \seqx \rangle$4, including multiplication, merge sort, and binary-search-style routines (Hu et al., 2021). QSynth synthesizes ten quantum unitary programs within at most about five minutes, whereas QFAST and QSyn often time out beyond 6 qubits (Deng et al., 2023).

The literature is equally explicit about limitations. The SyGuS looping method currently supports only “basic recursive/loop-like programs,” requires exact subtree equality, cannot yet synthesize loops whose operation changes by iteration number, is sensitive to constraint ordering in runtime, and requires the user to specify that recursion is desired (Berman et al., 2021). Origami’s harder schemes, especially Accu and Hylo, remain challenging; some patterns introduce unbound types that must be supplied by the user, and Ana and Hylo require iteration limits to avoid nontermination (Fernandes et al., 2024). Burst fails mainly on highly underconstrained specifications, where angelic recursion admits too many outputs and the FTA blows up (Miltner et al., 2021). QSynth restricts amplitudes to PPSA, relies on sparsity, allows at most one use of FIX, and does not directly synthesize nested fixed-point structures or higher-order oracles (Deng et al., 2023).

FractalBench exposes a different limitation: executable code is not the same as recovered recursive mathematics. The benchmark reports that $\langle \seqa, \pcname, \phi, \seqx \rangle$5 of outputs execute successfully but only $\langle \seqa, \pcname, \phi, \seqx \rangle$6 are visually correct, with models handling Koch-like geometric transformations better than branching recursion (Ondras et al., 9 Nov 2025). A plausible implication is that recursive function synthesis should not be conflated with surface-level code generation; the decisive difficulty often lies in recovering the invariant or self-referential structure that makes the recursive program semantically correct.

7. Recurring themes and common misconceptions

A common misconception is that recursion in synthesis is solved once a language or standard allows recursive syntax. The SyGuS literature directly contradicts this: recursion is permitted in the standard, yet existing solvers were characterized as good at loop-free programs but not at synthesizing recursive or looping functions (Berman et al., 2021). Another misconception is that recursive synthesis is simply ordinary synthesis plus a recursive-call operator. The surveyed work repeatedly shows that recursion changes the search problem, the verification problem, and the specification problem: one must reason about termination, recursive call structure, recurrence relations, inductive invariants, or self-similarity (Miltner et al., 2021, Hu et al., 2021, Ondras et al., 9 Nov 2025).

A second misconception is that resource-aware recursive synthesis requires an exact cost formula. SynPlexity’s central contribution is precisely to replace exact concrete resource expressions with asymptotic big-$\langle \seqa, \pcname, \phi, \seqx \rangle$7 bounds, thereby supporting logarithmic and divide-and-conquer algorithms that are naturally described by recurrences (Hu et al., 2021). A related misconception is that direct recursive search is always preferable to template or sketch bias. The evidence across Origami, SyntRec, and Cataclyst points the other way: recursion schemes, reusable templates, and syntactic pruning constraints often make the difference between intractable and practical search (Fernandes et al., 2024, Inala et al., 2015, Egolf et al., 7 Jan 2026).

The literature also distinguishes genuine recursive synthesis from adjacent problems. “Synthesiz3 This” is explicit that its methods apply directly to recursion-free single-invocation specifications and do not constitute a method for synthesizing recursive programs (Hozzová et al., 23 Apr 2025). This boundary is important for encyclopedia treatment because it separates first-order witness synthesis from synthesis of recursive definitions.

Taken together, these works portray recursive function synthesis not as a single algorithmic technique but as a family of approaches organized around one persistent obstacle: recursion introduces hidden structure that must be discovered, constrained, or verified. The most successful systems therefore do not treat recursion as a minor extension of loop-free synthesis. They reorganize the synthesis problem around unrolling, angelic assumptions, recursion schemes, type-level recurrence tracking, inductive proof rules, reusable templates, or explicit structural decompositions.