Symbolic Solver Ensembles

• Symbolic solver ensembles are systems that orchestrate multiple specialized solvers to exploit their complementary strengths for reliable synthesis.
• They are implemented via diverse architectures such as adaptive portfolios (e.g., CYANEA), parallel racing (e.g., NeuroSynt), and deterministic unions (e.g., ReaComp).
• These ensembles optimize performance by balancing solve rate, runtime, and cost, thereby outperforming single solvers in verification and efficiency.

Searching arXiv for the cited papers and closely related work on symbolic solver ensembles. Symbolic solver ensembles are computational systems that exploit solver complementarity rather than assuming that a single symbolic engine is uniformly dominant. In recent work, the term covers several distinct constructions: adaptive portfolios that select among symbolic solvers and LLM-plus-prompt configurations on a per-query basis; parallel portfolios that race neural and symbolic solvers under verification; and deterministic unions of multiple independently induced symbolic synthesizers whose outputs are filtered by an exact verifier. Adjacent neuro-symbolic systems further clarify the boundary of the concept by showing that a single symbolic solver coupled to a neural adviser or guider is collaborative, but not an ensemble in the strict multi-solver sense (Li et al., 9 Jan 2025, Cosler et al., 2024, Naik et al., 6 May 2026, Wang et al., 3 Jun 2026, Bertram et al., 2 Jul 2026).

1. Conceptual scope and architectural forms

The current literature does not treat symbolic solver ensembles as a single canonical algorithm. Instead, it presents several operational patterns. CYANEA is described as an online solver and prompt selection system that learns, per query, among a heterogeneous portfolio containing a symbolic solver and multiple LLM-plus-prompt combinations. NeuroSynt is a portfolio solver in the classical runtime sense: multiple solving strategies are launched in parallel and the first verified result is returned. ReaComp uses a different composition rule: it builds multiple standalone symbolic synthesizers offline, then unions them at test time and accepts the first exact solution found by any member. By contrast, BiNSGPS and G-RRM explicitly use one symbolic solver each, so they are not symbolic solver ensembles in the strict sense (Li et al., 9 Jan 2025, Cosler et al., 2024, Naik et al., 6 May 2026, Wang et al., 3 Jun 2026, Bertram et al., 2 Jul 2026).

System	Composition	Runtime rule
CYANEA	symbolic solver, GPT and Llama models, multiple prompt styles	rank solvers online and deploy sequentially
NeuroSynt	neural solver, symbolic synthesis solver, model checker	return the fastest valid result
ReaComp	multiple independently induced symbolic solvers	union candidates and verify exact solutions
BiNSGPS	one Symbolic Solver and one MLLM Adviser	iterative bidirectional feedback
G-RRM	one SE-RRM and one symbolic solver	neural guidance for search ordering

These forms share a common motivation stated explicitly in the synthesis literature: no single solver dominates across all tasks. CYANEA emphasizes that one LLM may dominate in one region, one prompt style in another, and a symbolic solver on tasks requiring exactness or short solutions. ReaComp reaches a similar conclusion through stochastic solver induction: different runs discover qualitatively different search algorithms, and those algorithms succeed on different subsets of tasks. NeuroSynt makes the same point for reactive synthesis by combining fast but untrusted neural proposal with sound and complete symbolic backstops (Li et al., 9 Jan 2025, Naik et al., 6 May 2026, Cosler et al., 2024).

Taken together, these systems suggest that symbolic solver ensembles are best understood as orchestration mechanisms over complementary symbolic search behaviors, often with verification as the acceptance criterion. The distinction between parallel racing, adaptive selection, and deterministic union is therefore central rather than incidental.

2. Query-adaptive selection in program synthesis

CYANEA formulates solver choice for program synthesis as a multi-armed bandit problem over a heterogeneous solver set that includes a symbolic enumeration/CEGIS-based solver, GPT and Llama models, and several prompt styles such as natural language, few-shot, higher-resource language translation via Lisp, role prompting, emotional stimuli, and combinations thereof (Li et al., 9 Jan 2025). A synthesis query is written as $q=\langle \tau, f, \phi \rangle$, where $\tau$ is the background theory, $f$ the function to synthesize, and $\phi$ the quantifier-free specification.

The contextual mechanism is $k$-Nearest Neighbor. For a new query, CYANEA computes a feature vector, finds the $k$ closest previously solved queries, aggregates rewards by solver over those neighbors, ranks solvers by score, and deploys them in that order. The system updates online after each solved query using the observed solver reward, runtime, and cost. A multi-layer bandit variant is also described, with a top bandit choosing between the symbolic solver and LLMs and lower-level bandits choosing prompt styles, but the single-layer version is reported as more stable in practice (Li et al., 9 Jan 2025).

CYANEA does not only rank solvers. It also allocates time and token-cost budgets and then calls solvers sequentially until one solves the query or budgets are exhausted. Candidate solutions are validated using an SMT solver, specifically cvc5. The evaluation uses 1269 synthesis queries drawn from ranking function synthesis literature, SyGuS competition benchmarks, and fresh unseen queries generated from SMT competition problems. The reported parameters are $T=100$ seconds per query, $C=100{,}000$ cost units, and $k=15$ (Li et al., 9 Jan 2025).

The reward design makes the optimization objective explicit. CYANEA studies a time-based reward

$$r^{t}= \begin{cases} 0 & \text{if query } q \text{ is unsolved},\ \left(1-\frac{t}{T}\right)^4 & \text{if solved}, \end{cases}$$

a cost-based reward

$\tau$0

and a binary reward

$\tau$1

For LLMs, cost is defined as input tokens plus three times output tokens, while the symbolic enumerator is assigned a fixed cost of $\tau$2 (Li et al., 9 Jan 2025).

The quantitative results position CYANEA as an adaptive ensemble rather than a static portfolio. It solves 37.2% more queries than the best single solver, reaches 88.3% solved against a 91.8% virtual best, and thus attains 96.1% of the virtual best’s score. The best single solver solves 64.3%. CYANEA’s Par-2 score is reported as less than 40% of the best single solver’s. The paper further reports that $\tau$3 gives the best Par-2 performance, $\tau$4 minimizes average cost, and $\tau$5 maximizes solve count for single $\tau$6-NN (Li et al., 9 Jan 2025).

3. Parallel portfolio solving in reactive synthesis

NeuroSynt presents a different ensemble pattern for reactive synthesis: a neural solver, symbolic synthesis solvers, and model checkers are integrated through a common framework, with multiple engines running in parallel and the first verified result returned as an AIGER circuit (Cosler et al., 2024). The pipeline begins with translation of a TLSF specification into an LTL assume-guarantee problem using SyFCo. The neural solver then generates candidate implementations; each candidate is checked by a model checker; and, in parallel, a symbolic solver is queried on the same synthesis problem.

The framework is modular. Components run in separate Docker containers and communicate through gRPC with protobuf messages such as SynProblem, SynSolution, MCProblem, and MCSolution. The neural solver returns an unsound synthesis result wrapper, and only model-checked candidates become acceptable outputs. This asymmetry is central: the neural model is used as a proposal mechanism, while model checking and symbolic synthesis ensure soundness and completeness (Cosler et al., 2024).

NeuroSynt supports and integrates symbolic tooling including Strix, BoSy, nuXmv, NuSMV, and Spot, while remaining extensible through a generic protobuf/gRPC interface. The portfolio policy is not a learned selector. It is a runtime competition among heterogeneous engines in which verified success, not raw proposal speed, determines acceptance (Cosler et al., 2024).

The reported evidence shows that the ensemble provides new coverage rather than merely duplicating symbolic solves. The neural solver alone solves 374 SYNTCOMP 2022 instances, BoSy alone solves 347, and NeuroSynt + BoSy solves 152 more instances than BoSy alone. NeuroSynt + Strix solves 31 more instances than Strix alone. A virtual best solver combining all SYNTCOMP 2022 tools solves 945 instances, and adding NeuroSynt’s neural solver yields 20 additional novel solves. When both neural and symbolic solvers solve the same realizable instances, the neural solver often returns smaller circuits, with 54.9% fewer latches than Strix and 42.3% fewer latches than BoSy (Cosler et al., 2024).

The ensemble logic here is classical portfolio solving under explicit correctness checks. Relative to CYANEA, which learns a query-specific sequential schedule, NeuroSynt relies on parallelism and arbitration by first verified completion.

4. Compiled unions of symbolic synthesizers

ReaComp introduces a third pattern: symbolic solver ensembles obtained by compiling LLM reasoning traces into reusable symbolic synthesizers over constrained DSLs, then unioning those solvers at test time with no LLM calls (Naik et al., 6 May 2026). The system has two stages. In offline solver induction, a coding agent receives a trace dataset of LLM reasoning traces, benchmark examples, and a verifier, and writes a standalone Python solver. In test-time hybrid inference, the induced solver runs first; if it finds a verifier-approved program, that answer is returned immediately at zero LLM cost; otherwise the system falls back to LLM search such as Best-of-K or Direct Feedback.

The induced solvers are deterministic domain-specific search procedures rather than generic theorem provers. On PBEBench they search over string-rewrite cascades of replace(A, B) with $\tau$7 and $\tau$8. On SLR-Bench they search Prolog rules such as eastbound(T) :- Body. over a constrained body vocabulary. In both domains, the solver code uses the verifier to score programs but prunes heavily before verification (Naik et al., 6 May 2026).

In this setting, “ensemble” means the union of multiple independently induced symbolic solvers. Reported constructions include CC + QO, the union of the Claude Code solver and one Qwen/OpenHands solver, and All Symbolic, the union of all 6 Qwen-induced PBE solvers plus the CC solver. Because each solver is standalone and deterministic, test-time ensembling requires only symbolic execution and exact verification, not additional LLM inference (Naik et al., 6 May 2026).

The complementarity argument is explicit. Different induction runs discover qualitatively different algorithms, including greedy plus residual fixing, safety-first greedy plus lookahead, unique-op permutations plus combinatorial search, multi-start greedy plus permutation reorder, adaptive beam search, and beam search without CoT. Since these algorithms explore different regions of the search space, unioning them increases coverage (Naik et al., 6 May 2026).

The empirical results are strongest on hard instances. On PBEBench-Lite, the CC solver reaches 80.4%, QO solver 65.7%, CC + QO 84.6%, and All Symbolic 91.3%. On PBEBench-Hard, BoK reaches 68.4%, CC solver 69.7%, QO solver 74.7%, CC + QO 81.2%, and All Symbolic 84.7%; thus All Symbolic beats BoK by 16.3 percentage points at zero LLM inference cost. The hybrid BoK + All Symbolic further improves PBEBench-Hard to 85.8% while reducing reported token usage by 78% relative to BoK alone. On SLR-Bench, DF + CC raises hard-tier accuracy from 34.4% to 58.0%, and DF + CC + QO reaches 86.7%. On the historical linguistics transfer task, ensembling reaches 80.1% zero-shot accuracy under “All solvers except the bad run 3” (Naik et al., 6 May 2026).

This ensemble type is neither a learned gate nor a statistical average. It is a deterministic coverage aggregator with verifier-mediated selection and strong amortization properties after the one-time induction cost.

5. Verification, reward, and cost as ensemble design axes

Across the synthesis systems, ensemble efficacy is inseparable from acceptance criteria and resource accounting. CYANEA validates candidate programs using cvc5 and optimizes explicitly over solve rate, runtime, and cost through $\tau$9, $f$0, and $f$1. ReaComp uses a task-level verifier reward $f$2, returns immediately when a verifier-approved program is found, and otherwise falls back to LLM search. NeuroSynt treats neural outputs as provisional until they pass model checking, exploiting the fact that LTL model checking is cheaper than reactive synthesis (Li et al., 9 Jan 2025, Naik et al., 6 May 2026, Cosler et al., 2024).

Cost models differ, but cost is never incidental. CYANEA defines LLM cost as input tokens plus three times output tokens and assigns the symbolic enumerator a small fixed cost of $f$3. ReaComp emphasizes zero-token execution thereafter once solvers have been induced, reporting QO induction costs around $f$41.34 per solver, CC induction around $f$54, symbolic inference over all tasks in under 5 minutes, and LLM BoK/DF runs taking about 2 days per benchmark at 8 workers. NeuroSynt, by contrast, is organized around latency competition and first verified completion rather than an explicit token budget (Li et al., 9 Jan 2025, Naik et al., 6 May 2026, Cosler et al., 2024).

These design choices imply different notions of optimality. In CYANEA, “best” depends on the reward function. In ReaComp, “best” is coverage under exact verification with low amortized inference cost. In NeuroSynt, “best” is the earliest sound synthesis result among competing engines. This suggests that symbolic solver ensembles should be classified not only by composition, but also by how they define success.

6. Adjacent neuro-symbolic systems that are not symbolic solver ensembles

BiNSGPS and G-RRM are closely related to symbolic solver ensembles but deliberately fall outside the strict multi-solver category. BiNSGPS addresses geometry problem solving with one Symbolic Solver and one MLLM Adviser linked by bidirectional feedback. When the solver encounters a logical conflict / contradiction, the adviser rectifies inconsistent representations; when it reaches a deductive deadlock, the adviser proposes auxiliary hypotheses. The system is therefore a closed-loop neuro-symbolic collaboration rather than an ensemble of symbolic engines. Its reported results are 95.2% choice and 90.5% completion on Geometry3K, and 92.7% choice and 90.1% completion on PGPS9K, with an ablation showing that removing the MLLM Adviser drops completion to 73.3% / 72.1% (Wang et al., 3 Jun 2026).

G-RRM likewise uses one neural guider + one symbolic solver. The SE-RRM predicts a full Sudoku assignment, and a symbolic solver such as backtracking, Glucose 4.1, or CaDiCaL 3.0.0 uses those predictions only to order search while preserving all feasible assignments and global correctness. The paper is explicit that this is not a multi-solver symbolic ensemble. Its central result is conditional utility: guidance helps when the search space is expansive and the solver can overwrite poor branching hints. Under those conditions, the reported median speedups on $f$6 Sudoku are 33.251× for backtracking and 1.699× for Glucose 4.1, while CaDiCaL 3.0.0 shows no significant speedup and a small significant mean slowdown on $f$7 (Bertram et al., 2 Jul 2026).

These boundary cases matter conceptually. They show that multi-component neuro-symbolic systems can achieve strong empirical results without constituting solver ensembles. The decisive criterion is whether multiple symbolic search procedures are composed, selected, raced, or unioned, rather than whether symbolic reasoning is merely present.

7. Symbolic environments and ensemble semantics

A distinct use of the term appears in work on epistemic ensembles, where the ensemble is a collection of concurrently running, knowledge-based agents rather than a portfolio of search procedures. In that setting, the key distinction is between a semantic environment given by a non-empty class of epistemic states and a symbolic environment given by a finite knowledge base over a focus set $f$8. The bridge is $f$9-equivalence: a class of epistemic states $\phi$0 and a symbolic state $\phi$1 are equivalent when, for every $\phi$2, $\phi$3 iff $\phi$4 (Hennicker et al., 2024).

The symbolic environment is updated via weakest liberal preconditions, while the semantic environment is updated via product update over epistemic actions. Under representability assumptions, the paper proves that equivalent semantic and symbolic configurations simulate each other and satisfy the same dynamic epistemic ensemble formulas. At the configuration level, if $\phi$5 and $\phi$6 are equivalent, then for all ensemble formulas $\phi$7,

$\phi$8

This yields a correctness-preserving finite abstraction of multi-agent epistemic dynamics (Hennicker et al., 2024).

Although this line of work is not about runtime solver portfolios, it broadens the notion of symbolic ensembles. It shows that “ensemble” can denote not only orchestration among solvers, but also a formal semantics for coordinated symbolic agents operating over shared knowledge states. A plausible implication is that the phrase symbolic solver ensembles now spans both operational architectures for exact reasoning under heterogeneous guidance and formal symbolic realizations of collective reasoning systems.