Mathematical discoveries from program search with large language models (FunSearch)
Product### Audio Processing <a name="2023ap"></a>
Capabilities6 decomposed
program-space search with llm-guided exploration
Medium confidenceSearches through discrete program spaces (e.g., algorithm implementations, mathematical proofs) by using an LLM as a heuristic guide to propose candidate programs, then evaluates them against test cases or mathematical constraints. The system iteratively refines the search by learning from successful and failed program attempts, effectively treating program synthesis as a guided exploration problem rather than pure generation.
Uses LLM as a learned heuristic within a structured search loop rather than as a one-shot generator, combining neural guidance with deterministic evaluation to explore discrete program spaces. Implements iterative refinement where the LLM learns from failed attempts through in-context examples, enabling discovery of solutions outside typical training data distributions.
Outperforms pure LLM code generation by grounding proposals in executable feedback, and outperforms traditional program synthesis by leveraging learned heuristics to prune the search space intelligently rather than relying on exhaustive enumeration or hand-crafted rules.
iterative program refinement with failure-driven learning
Medium confidenceMaintains a feedback loop where failed program attempts are converted into in-context examples that guide the LLM toward better proposals in subsequent iterations. The system tracks which program structures, algorithmic patterns, and constraint violations led to failures, then uses this history to steer the LLM away from unpromising regions of the solution space.
Implements a closed-loop learning system where failure information is explicitly encoded into prompts as negative examples, allowing the LLM to adapt its generation strategy without fine-tuning. Uses the LLM's in-context learning capability as a lightweight alternative to gradient-based optimization.
More sample-efficient than pure random search because failures directly inform future proposals, and faster than fine-tuning-based approaches because it avoids retraining overhead while still adapting to problem-specific constraints.
constraint-aware program generation with multi-objective evaluation
Medium confidenceGenerates program candidates that must satisfy multiple evaluation criteria simultaneously (e.g., correctness on test cases, runtime performance, code simplicity, mathematical elegance). The system ranks candidates by a composite score that balances these objectives, allowing users to explore trade-offs between solution quality dimensions.
Embeds multi-objective evaluation directly into the program search loop, allowing the LLM to see composite scores and trade-offs during generation. This differs from post-hoc ranking because the LLM can learn which objective combinations are achievable and adjust proposals accordingly.
More nuanced than single-metric optimization because it exposes solution trade-offs, and more practical than pure Pareto enumeration because the LLM's guidance reduces the number of candidates that need evaluation.
domain-specific program synthesis with problem-aware prompting
Medium confidenceTailors LLM prompts to specific problem domains (e.g., combinatorial optimization, mathematical sequences, algorithm design) by embedding domain knowledge, common patterns, and successful solution templates into the prompt context. The system adapts its generation strategy based on the problem class, improving proposal quality without retraining.
Encodes domain expertise as structured prompt context rather than as hard-coded rules or fine-tuned models, enabling rapid adaptation to new domains while maintaining the generality of the underlying LLM. Uses problem-aware prompting to guide the LLM toward domain-appropriate solutions.
More flexible than domain-specific code generators because it leverages the LLM's general reasoning, and more practical than generic program synthesis because domain knowledge directly improves proposal quality and reduces search time.
mathematical conjecture validation through program discovery
Medium confidenceAutomatically discovers programs (algorithms, constructions, proofs) that either validate or refute mathematical conjectures by searching for counterexamples or constructive proofs. The system translates mathematical statements into executable test cases or constraint specifications, then uses program search to find solutions that satisfy or violate the conjecture.
Bridges mathematical reasoning and program synthesis by translating conjectures into executable specifications, then using program search to explore the solution space. Treats mathematical discovery as a search problem rather than a pure reasoning task.
More systematic than manual exploration because it exhaustively searches bounded domains, and more practical than formal theorem proving because it uses heuristic search rather than requiring hand-crafted proofs.
scalable evaluation and ranking of program candidates
Medium confidenceEfficiently evaluates large numbers of program candidates (100s to 1000s) against test suites and performance metrics, then ranks them by quality scores. The system uses parallel evaluation, caching, and early termination to reduce computational overhead while maintaining ranking accuracy.
Implements a scalable evaluation pipeline that treats program testing as a data processing problem, using caching, parallelization, and early termination to handle large candidate pools efficiently. Decouples evaluation from generation, allowing flexible ranking strategies.
More efficient than sequential evaluation because it parallelizes test execution, and more flexible than hard-coded ranking because it supports pluggable evaluation metrics and ranking algorithms.
Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.
Related Artifactssharing capabilities
Artifacts that share capabilities with Mathematical discoveries from program search with large language models (FunSearch), ranked by overlap. Discovered automatically through the match graph.
Large Language Models as Optimizers (OPRO)
* ⏫ 10/2023: [Eureka: Human-Level Reward Design via Coding Large Language Models (Eureka)](https://arxiv.org/abs/2310.12931)
AlphaCodium
Official implementation for the paper: "Code Generation with AlphaCodium: From Prompt Engineering to Flow Engineering""
Voyager
LLM-powered lifelong learning agent in Minecraft
BabyElfAGI
Mod of BabyDeerAGI, with ~895 lines of code
code-act
Official Repo for ICML 2024 paper "Executable Code Actions Elicit Better LLM Agents" by Xingyao Wang, Yangyi Chen, Lifan Yuan, Yizhe Zhang, Yunzhu Li, Hao Peng, Heng Ji.
Mistral: Devstral 2 2512
Devstral 2 is a state-of-the-art open-source model by Mistral AI specializing in agentic coding. It is a 123B-parameter dense transformer model supporting a 256K context window. Devstral 2 supports exploring...
Best For
- ✓Research teams exploring mathematical conjectures and algorithm discovery
- ✓Optimization specialists seeking novel solutions to NP-hard or combinatorial problems
- ✓Academic institutions validating computational mathematics hypotheses
- ✓Teams running long-horizon program search experiments where iteration count is high (100s to 1000s of attempts)
- ✓Researchers studying how LLMs learn from negative examples in structured domains
- ✓Optimization workflows where solution quality improves monotonically with iteration
- ✓Algorithm researchers optimizing for both theoretical and practical performance
- ✓Mathematicians seeking proofs that are both correct and insightful
Known Limitations
- ⚠Requires well-defined evaluation metrics or test suites to judge program correctness — works poorly on subjective or open-ended problems
- ⚠Search time grows exponentially with program complexity and constraint count; practical for small-to-medium programs only
- ⚠LLM guidance is probabilistic and may miss solution regions if training data doesn't cover similar problem structures
- ⚠No guarantees of optimality or completeness — discovered solutions are heuristically good, not proven optimal
- ⚠Context window limits the number of failure examples that can be retained — typically 10-50 examples before context overflow
- ⚠LLM may overfit to recent failures and miss alternative solution strategies if failure patterns are not diverse
Requirements
Input / Output
UnfragileRank
UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.
About
### Audio Processing <a name="2023ap"></a>
Categories
Alternatives to Mathematical discoveries from program search with large language models (FunSearch)
Are you the builder of Mathematical discoveries from program search with large language models (FunSearch)?
Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.
Get the weekly brief
New tools, rising stars, and what's actually worth your time. No spam.
Data Sources
Looking for something else?
Search →