Large Language Model–Symbolic Solver (LLM-SS)

• LLM-SS is a hybrid paradigm that combines neural program synthesis with rigorous symbolic search for automated reasoning.
• It employs a contextual multi-armed bandit for dynamic solver selection and budget allocation based on featurized query inputs.
• Benchmarking with systems like CYANEA shows improved solve rates and significant cost reductions compared to traditional single-solver approaches.

A LLM–Symbolic Solver (LLM-SS) is an architectural paradigm for automated reasoning, program synthesis, and logical inference in which LLMs are orchestrated alongside, or integrated with, symbolic search engines or deductive engines. The core motivation is to leverage the complementary strengths of neural and symbolic approaches: LLMs deliver flexible program synthesis and auto-formalization from complex, language-rich inputs, while symbolic solvers offer principled, error-free search and verification. Recent research has introduced sophisticated frameworks that combine online model selection, contextual prompting, and adaptive budget allocation to maximize efficiency and robustness in program synthesis and symbolic reasoning tasks.

1. System Architecture and Execution Pipeline

CYANEA exemplifies a modern LLM-SS system with a distinct runtime loop, which encompasses the following four stages (Li et al., 9 Jan 2025):

1. Featurization:
   • Input: SyGuS-IF synthesis query $q$.
   • Output: Feature vector $f(q)$ (e.g., SMT-LIB keyword counts, query length, constant stats, logic identifier such as LIA/BV/INV).
2. Model/Prompt Selector (Bandit Agent):
   • Input: $f(q)$ and trial history $D = \{(f_i, s_i, r_i)\}$.
   • Output: Ranked solver list $S = \{s_1, ..., s_n\}$ where each $s_i$ is an (LLM, prompt-style) tuple or a symbolic engine.
3. Budget Allocator:
   • Allocates, for each $s_j$, a token budget $c_j$ and time budget $t_j$ using an exponential fit to historical costs/runtimes among k-nearest neighbors of $f(q)$.
4. Deploy & Update:
   • Sequentially tries $f(q)$0 by ranking, invoking either:
     • An LLM (e.g., OpenAI GPT-3.5-turbo-0125, Meta LLaMA-3-70B) via API with prompt template $f(q)$1 (embeds $f(q)$2 and restricts input/output token usage to $f(q)$3).
     • The symbolic solver: a CEGIS-A* enumerator with cvc5 for candidate checking.
   • Measures actual solve time $f(q)$4, cost $f(q)$5, checks functional correctness (via SMT-solver on candidate), computes reward $f(q)$6 using the selected reward function, logs to $f(q)$7, and if solved, terminates further trials.

This runtime design can be implemented as a single-layer or a two-layer bandit: the former ranks all arms globally, while the latter discriminates "LLM vs. symbolic" first, then chooses prompt/model in a second bandit step.

2. Multi-Armed Bandit Formulation and Budget Adaptation

The solver/model/prompt selection process is formalized as a contextual multi-armed bandit (MAB) problem:

• Arms ($f(q)$8): Each candidate solver (LLM/prompt or symbolic).
• Contextual Selection: $f(q)$9-Nearest Neighbor regression in feature space; for each incoming $f(q)$0, the agent locates historical neighbors to $f(q)$1. Arms are ranked by cumulative past reward $f(q)$2 on similar queries.
• Reward Functions: Three candidates:
  • Binary: $f(q)$3 if solved within budget, $f(q)$4 otherwise.
  • Time-sensitive: $f(q)$5 for runtime $f(q)$6.
  • Cost-sensitive: $f(q)$7 for cost $f(q)$8.
• Budget Estimation: For each $f(q)$9, exponential-model parameters for cost/time are fit using MLE on neighbor data to select budgets $D = \{(f_i, s_i, r_i)\}$0, $D = \{(f_i, s_i, r_i)\}$1 so that probability of exceeding budget is below a threshold ($D = \{(f_i, s_i, r_i)\}$2 for tokens, $D = \{(f_i, s_i, r_i)\}$3 for time).

This design ensures adaptive resource allocation and discourages waste of API tokens or solver compute on low-probability arms.

3. Prompting Matrix and Solver Integration

CYANEA employs a curated matrix of six LLM prompt templates, toggling between:

• Inclusion of natural-language constraint descriptions.
• Few-shot exemplars (e.g., three solved SyGuS queries).
• Multi-stage conversions through a high-resource PL (e.g., Lisp to SyGuS-IF).
• "Role" prefixes ("You are a good program synthesizer.").
• "Emotional" cues in the prompt tail ("…Please don't fail me.").

Each (LLM, prompt-style) pair acts as a separate arm in the bandit, and their relative success/failure is tracked and updated online.

Both LLM-based and symbolic solvers are controlled via a uniform API: LLMs are called with input token limits ($D = \{(f_i, s_i, r_i)\}$4), and output generation is terminated both on functional finish and on token budget exhaustion; symbolic solvers are invoked via the CEGIS-A* scheme, with cvc5 serving as the candidate enumerator and validator. All failure/time-out paths are treated equivalently across LLM and symbolic arms (flagged as unsuccessful, with appropriate resource consumption logged).

4. Experimental Benchmarking and Results

CYANEA was benchmarked on 1,269 synthesis queries, including SyGuS Competition suites (bit-vectors, arithmetic, PBE, invariants), ranking function synthesis, and fresh SMT queries (Li et al., 9 Jan 2025).

Reported metrics include:

• The percent solved under binary reward.
• Par-2 score (sum of runtime per solved query, $D = \{(f_i, s_i, r_i)\}$5 per unsolved).
• Cumulative token/cost usage.

Key outcomes:

Method	% Solved	Par-2	Cumulative Cost
Best single solver	64.3%	~54,000	Baseline
CYANEA (r^c)	88.3%	~24,000	>50% reduction
Virtual Best	91.8%	—	—

CYANEA performs within $D = \{(f_i, s_i, r_i)\}$6 of the virtual best (oracle) solver, outperforms the strongest single-arm baseline by $D = \{(f_i, s_i, r_i)\}$7 more queries solved, and more than halves cumulative cost relative to naive ensembling.

5. Comparative Strengths, Limitations, and Strategies

Empirical insights:

• LLMs surpass symbolic CEGIS on string-manipulation and rich PBE tasks, where deep theory or loop-invariant synthesis is less critical.
• Symbolic search excels on short/arithmetic-heavy invariant synthesis or tasks tightly coupled to formal logic theories.
• The contextual k-NN bandit adapts rapidly and robustly across new domains without rigid parametric bias.
• Layered bandits (model $D = \{(f_i, s_i, r_i)\}$8 prompt) risk overfitting under sparse data regimes; the flat bandit design uniformly over all arms is more robust for constrained resource settings.

Reward design via power-law (e.g., $D = \{(f_i, s_i, r_i)\}$9 for time or $S = \{s_1, ..., s_n\}$0 for tokens) effectively punishes timeouts/expensive queries and accelerates convergence to cost-efficient policies.

6. Design Principles and Generalization

The key design pattern instantiated by CYANEA is fully general: any black-box solver portfolio (LLMs, symbolic, procedural, or hybrid engines) can be managed as arms in this architecture. The reward function can be arbitrarily reshaped to reflect user priorities (speed, correctness, cost, diversity). Online logging and contextual bandit updates ensure continual domain adaptation.

Best practices for deploying LLM-SS systems in program synthesis and related domains:

• Featurize each query to maximize discrimination in bandit history.
• Rely on non-parametric selection (k-NN, contextual bandits) for rapid adaptation.
• Build a rich prompt matrix and track success per (model, style) pair to exploit heterogeneity in LLM behavior.
• Avoid premature overstratification of arms (e.g., explicit model-choice routing), especially under tight training or data regimes.
• Control API and compute costs via principled, history-aware budget allocation.

7. Broader Significance and Future Directions

The LLM–Symbolic Solver framework, as realized by CYANEA, represents a robust, dynamically adaptive, and resource-efficient synthesis architecture that is competitive with or outperforms monolithic symbolic or purely LLM-based approaches (Li et al., 9 Jan 2025). This paradigm is extensible to richer solver portfolios, alternative reward structures, and broader synthesis and reasoning domains, with principled online adaptation mechanisms likely to remain core to the continued advancement of hybrid neuro-symbolic systems.