Conjecture Extraction: Techniques & Applications

• Conjecture Extraction is the process of deriving precise mathematical statements from informal or partial representations such as program terms, graphs, and diagrams.
• It employs test-driven, enumerative, and data-driven methods to systematically propose candidate equations or rewrite rules for further validation.
• Its applications span formal theorem proving, diagrammatic reasoning, and invariant optimization, enabling robust intermediate validation of mathematical insights.

Conjecture extraction denotes the production of explicit mathematical statements from a prior representation such as program terms, graph invariants, diagrammatic expressions, informal problem statements, or partially specified knowledge states. In theory exploration, it is the operation that turns generated terms into candidate equational laws (Johansson et al., 2021). In diagrammatic reasoning, it is the synthesis of candidate graphical identities from composed generators evaluated in a concrete model (Kissinger, 2012). In formal mathematics, it is the step that converts an informal problem into a precise conclusion—such as a value, bound, or proposition—before formalisation and proof can proceed (Sivakumar et al., 13 Oct 2025). This suggests a common role for conjecture extraction as an intermediate layer between representation and verification.

1. Conceptual scope and output forms

Across the literature, conjecture extraction is not identified with proof search. QuickSpec treats it as the proposal of universally quantified equational laws $t_1=t_2$ over typed variables, optionally with guards declared by the user (Johansson et al., 2021). In formal reasoning benchmarks for Lean, the conjecture is the mathematical conclusion that must be inferred from the hypotheses so that the formal theorem can typecheck and later be proved (Sivakumar et al., 13 Oct 2025). In graphical theories, the extracted object is a rewrite rule between string graphs, selected from semantically equivalent diagrams while redundant candidates are suppressed (Kissinger, 2012).

The output language depends on the domain. Functional-program theory exploration yields equations, often conditional equations, over a typed signature. Diagrammatic synthesis yields rewrite systems on string graphs. Geometry repositories encode a conjecture as a three-part object—hypothesis, non-degenerate conditions, and conclusion—inside an XML container linked to a construction file and optional proof-attempt metadata (Quaresma, 2012). In formal theorem proving, standalone conjecture generation can be required to output a concise Lean 4 expression, while autoformalisation requires the same conclusion to be embedded into a full theorem statement (Sivakumar et al., 13 Oct 2025).

This diversity of output forms indicates that conjecture extraction is not tied to a single logical format. What remains stable is the requirement that the output be precise enough for downstream validation, whether by random testing, theorem proving, tactic execution, model checking, or schema validation.

2. Enumerative and test-driven methods

A canonical test-driven approach is QuickSpec. It takes a typed signature, variable schemas, and exploration parameters, then enumerates well-typed terms layer by layer by size, evaluates them on random valuations, partitions them into equivalence classes by test-result vectors, and emits conjectures by equating a chosen representative with the other terms in its class. Newly discovered equations are oriented into rewrite rules, and subsequent enumeration keeps only terms that are irreducible with respect to the accumulated rewrite system. Defaults around $n=1000$ random tests are reported as effective for unconditional laws, while guarded conjectures often use $n=10000$. The system has been used to generate lemmas for HipSpec, export conjectures to Isabelle/HOL and HOL4 through Hipster/Hopster, and operate through TIP/tip-spec; empirically, it generated $23$ readable laws for Naturals with $+$, $*$, and $\gcd$ in about $5$ seconds, and in a TIP/Vampire experiment on $50$ inductive benchmarks, Vampire alone proved $7$ whereas QuickSpec-generated lemmas raised this to $n=1000$0 (Johansson et al., 2021).

The same irreducibility principle is adapted to diagrams in string-graph synthesis. There, conjecture extraction works over a monoidal signature and a graph rewrite system. Only irreducible string graphs are enumerated; semantic equivalence is determined by evaluation in a concrete model, such as linear maps; and $n=1000$1-minimal representatives are chosen as normal forms. For bounded sizes, the synthesized system is complete in the sense that semantically equal graphs reduce to minimal representatives or are connected by congruence rules. In the GHZ/W case study, naive enumeration produced $n=1000$2 rewrite rules, whereas redex-eliminating synthesis produced $n=1000$3, including all rules used to define the GHZ/W-calculus (Kissinger, 2012).

These methods share a distinctive architecture: generate candidate expressions, identify observational or semantic coincidence classes, and aggressively eliminate reducible forms before the next stage of search. The technical burden lies less in proposing equations than in controlling the combinatorial explosion of the search space.

3. Data-driven, geometric, and modal frameworks

A contrasting line of work treats conjecture extraction as a problem of fitting templates to invariant data. TxGraffiti represents each mathematical object, primarily a graph, as a row of numerical invariants and Boolean properties. It generates affine upper and lower bounds by solving linear programs for each target invariant, feature column, and predicate combination, ranks candidates by touch number—the number of objects on which the inequality is sharp—and filters redundancies with a static adaptation of the Dalmatian heuristic based on sharpness sets. The system emphasizes precomputed invariants rather than on-the-fly computation, supports a web interface, and has generated or recovered statements such as $n=1000$4, $n=1000$5 in bipartite graphs by matching upper and lower bounds, and $n=1000$6 for regular connected graphs (Davila, 2024).

A more abstract formalization appears in work on machine intelligence for inequality conjectures. There the conjecture space is

$n=1000$7

an open subset of a Banach space of continuous-function pairs, hence a Banach manifold. The paper studies linear automorphisms preserving this space, identifies subgroups such as $n=1000$8, $n=1000$9, and $n=10000$0, analyzes free actions through $n=10000$1 and $n=10000$2, and proposes geometric gradient descent with symmetry-informed metrics to search for new conjectures. Its proof-of-concept examples include inequalities for the prime-counting function, notably $n=10000$3 for $n=10000$4, and exploratory bounds on diameters of Cayley graphs of non-abelian simple groups (Mishra et al., 2023).

A different formalism treats conjecture extraction as reasoning from knowledge under hypothetical extension. In the modal systems KC and KDC, Axiom $n=10000$5, $n=10000$6, preserves established facts across conjectural layers, while a paracomplete semantics avoids modal collapse by rejecting $n=10000$7 and allowing undefined propositions. Conjectural layers extend a base partial valuation with consistent hypotheses, target formulas are evaluated by the three-valued semantics of $n=10000$8, and the dynamic operation $n=10000$9 promotes a conjecture to accepted fact by updating the base valuation. The systems are presented as complete and decidable and as robust under partial knowledge (Vitali, 10 Aug 2025).

Taken together, these frameworks show that conjecture extraction can be modelled as optimization over invariant features, as search on a structured function manifold, or as controlled extension of a knowledge state. The shared pattern is the explicit management of admissible transformations and admissible uncertainty.

4. Conjecture extraction in formal theorem proving

Recent work in formal mathematics isolates conjecturing as a separate benchmarked capability. ConjectureBench augments PutnamBench and CombiBench to create $23$0 paired informal–formal items, comprising $23$1 Putnam problems and $23$2 CombiBench problems after splitting multi-part items. The dataset distribution is $23$3 numerical, $23$4 algebraic, and $23$5 proof/truth tasks. It distinguishes a seen setting, where the correct Lean conjecture is provided, from an unseen setting, where only the informal statement is given, and also evaluates standalone conjecture generation. The metrics include ConJudge for detecting whether the generated formalisation correctly incorporates the gold conjecture, and equiv_rfl for checking definitional equality of standalone conjectures by Lean’s rfl. The reported results show that autoformalisation performance is substantially overestimated when the conjecture is assumed: the average drop from seen to unseen is $23$6. Lean-FIRe, a two-stage inference-time method combining Chain-of-Thought and Lean-of-Thought prompting, achieves the first successful end-to-end autoformalisation of $23$7 PutnamBench problems with GPT-4.1 and $23$8 with DeepSeek-V3.1 under the paper’s strict evaluation (Sivakumar et al., 13 Oct 2025).

LeanConjecturer addresses the same bottleneck from the data-generation side. Starting from a Mathlib seed file, it performs rule-based context extraction—imports, variables, namespaces, simple definitions—and then uses an LLM to generate Lean 4 theorem statements ending with := by. Candidate statements are checked for syntactic validity by replacing proofs with sorry, filtered for novelty by Lean’s exact? against Mathlib and the accumulated local context, and marked non-trivial if they cannot be solved by aesop. From $23$9 Mathlib seed files, the system produced $+$0 conjectures, of which $+$1 were syntactically valid, $+$2 novel, and $+$3 non-trivial. The average number of novel conjectures per seed file was $+$4. Generated topology statements on semi-open, alpha-open, and pre-open sets were successfully verified, and GRPO training on generated conjectures increased successful proofs on a $+$5-problem topology set from $+$6 to $+$7, then to $+$8, with problem-level success increasing from $+$9 to $*$0 and then $*$1 (Onda et al., 27 Jun 2025).

These systems treat conjecture extraction as a prerequisite for proof, not a side effect of proof search. In formal environments, the central difficulty is often not proving a finished theorem, but assembling the correct theorem statement in the first place.

5. Representation, interchange, and domain-specific packaging

In geometry, conjecture extraction has also been treated as a problem of interoperable representation. The XML extension to the Intergeo format adds a conjecture.xml component to the existing construction format and organizes conjectures into hypothesis, ndg, and conclusion, with references to objects defined in intergeo.xml. The same container may include information.xml for human metadata, proofInfo.xml for proof-attempt metadata, and directories for previews, resources, and tool-specific payloads. Proof attempts record method, status, limits, measures such as CPU time, and platform data, while statuses reuse an SZS-based classification adapted to geometry. Except for intergeo.xml, files are optional, so partial packages remain valid and backward compatible with tools that only understand the construction layer (Quaresma, 2012).

This representation has two consequences. First, it externalizes conjecture extraction into a portable object that can be exchanged among dynamic geometry systems, geometry automated theorem provers, and repositories such as GeoThms, TGTP, and Web Geometry Laboratory. Second, it separates the conjecture itself from proof artifacts and from human-readable descriptions, which allows repositories to index, search, and curate conjectures even when no formal proof object is shared.

A plausible implication is that standardized packaging changes what counts as “extracted.” In such systems, extraction is complete only when the conjecture has been bound to a construction vocabulary, side conditions, and proof-attempt metadata.

6. Validation, limitations, and open directions

The literature repeatedly treats validation as a distinct phase with its own failure modes. QuickSpec primarily targets unconditional equational laws and supports conditional laws only over declared predicates; it does not provide general richer logics out of the box, and its random-testing basis can miss sparse counterexamples or generate spurious equalities if the observe function is poorly chosen. It also does not certify completeness of the discovered law set, so completeness remains a manual or prover-level argument (Johansson et al., 2021).

TxGraffiti imposes a different limitation: its main search class is affine-linear inequalities, usually one feature at a time, with multi-feature variants treated as extensions rather than the default. The system is vulnerable to dataset bias and overfitting, depends on precomputed invariants whose exact evaluation may already be NP-hard, and uses heuristics such as touch-number ranking, Pepper’s Rule, TicTac, and Red Burton to manage triviality and refutation rather than to prove correctness (Davila, 2024).

Formal-math benchmarks expose an additional difficulty: conjecturing and formalisation fail differently. In ConjectureBench, standalone conjecture generation remains weak; GPT-4.1 achieved $*$2 pass@1 and $*$3 pass@10 overall under equiv_rfl, while DeepSeek-V3.1 achieved $*$4 and $*$5, with especially poor results on proof/truth tasks. The reported errors include missing conditions or quantifiers, incorrect bounds, incomplete but valid partial answers, and contamination from helper definitions in gold formalisations (Sivakumar et al., 13 Oct 2025). LeanConjecturer, meanwhile, defines non-triviality operationally as “cannot be proven by aesop,” so accepted conjectures may still be false until stronger verification is supplied (Onda et al., 27 Jun 2025).

These limitations indicate that conjecture extraction is unlikely to converge to a single dominant method. Test-based systems excel at algebraic law discovery, invariant-based systems excel at numerical inequalities, formal-language pipelines excel at proof-assistant integration, and interchange formats excel at curation. The current research frontier lies in combining expressive search spaces with strong validators while preserving syntactic well-formedness, semantic novelty, and downstream usability.