Can Prolog-Based Chain-of-Thought Imitation Improve LLM Reasoning?

A Prolog engine writes the training answers

Thought-Like-Pro (TLP) targets a specific weakness: a language model generating a chain of thought token by token can make one bad step and then compound it, and prompt-based fixes such as Chain-of-Thought, Tree-of-Thoughts or Graph-of-Thoughts need task-specific tuning. The paper's alternative is to stop trusting the model's own reasoning text as training data and instead let a symbolic engine decide what a correct reasoning path looks like.

The pipeline runs in three moves. An open-source chat model is prompted, with instructions and demonstrations, to turn a problem into Prolog rules, facts and a query. The Prolog engine then executes that program and returns a derivation, which is checked against the known answer; only verified derivations are kept. Finally the model converts those Prolog derivations into natural-language chain-of-thought text, and that text becomes the supervised fine-tuning target. The process is prompt-guided but self-bootstrapped: the model supplies the formalization, the engine supplies the correctness filter.

Verification separates this from ordinary CoT fine-tuning

The distinction matters because the training signal changes. Fine-tuning on human-written or model-sampled rationales can teach a model to reproduce reasoning that was never checked; the paper notes that LLMs sometimes reach correct answers through erroneous internal steps, so process and outcome can diverge. A Prolog derivation, by contrast, is produced by deterministic deduction over the supplied facts and rules, so a kept trajectory is logically valid given its premises.

The authors argue this quality, not sheer quantity of sampled rationales, explains the gains: TLP stays competitive with baselines that also use multiple reasoning paths, such as Self-Consistency, and TLP trained on a single trajectory sometimes outperforms models fine-tuned on ground-truth trajectories. That comparison is the paper's own interpretation of its results, and it rests on the benchmark tables rather than on an inspection of what the models internally learned.

The LLM-to-Prolog step is the practical bottleneck

A natural worry is that the whole pipeline collapses if the model cannot write valid Prolog. The paper measures this indirectly: on tasks fully tractable by symbolic deduction, the CARING baseline, which also routes through Prolog, reaches near-perfect accuracy even with 8B backbones — 100% on ProofWriter and PrOntoQA, 97.6% on QASC and 98.1% on GSM8K. Because Prolog is deterministic here, a correct executable translation yields the right answer and a malformed one does not, so that accuracy is a proxy for end-to-end translation validity, with failures at most a few percent.

That proxy also defines the ceiling. CARING is treated as an upper bound within the Prolog paradigm, and TLP's job is to close the gap to it by learning from verified trajectories rather than calling the solver at inference time.

Gains appear across backbones and training recipes

On Prolog-tractable benchmarks, TLP improves over the corresponding base model for both Llama3-8B-Instruct and Qwen3-8B. Under the multiple-trajectory configuration it reaches 87.81 on GSM8K, 98.19 on ProofWriter, 100.00 on PrOntoQA and 96.70 on QASC with Llama3-8B, and 95.54, 99.75, 100.00 and 98.30 respectively with Qwen3-8B. The improvement is not tied to one recipe: model-averaged variants (MA+single, MA+multiple) and non-averaged variants (single, multiple) all gain, with multiple typically best.

The paper reads the multiple-trajectory advantage as better modeling of the varied reasoning paths a model can take for one instruction, which would make the learned behavior more robust. Training with more trajectories per instruction also produced larger gains than a single trajectory in the reported evolution curves.

Model averaging limits the out-of-distribution drop

Domain-specific fine-tuning risks catastrophic forgetting, so the authors average the fine-tuned weights with the original model. The abstract reports that with model averaging the method shows only a marginal decline on distributional extrapolation tasks, which the authors present as robust generalization. The results section frames the same trade-off more concretely: model averaging is the stable option when one wants to give up a small amount of peak in-domain performance for better retention and robustness.

These are two different claims and should not be merged. The in-domain numbers above are benchmark accuracies on Prolog-tractable tasks; the extrapolation claim concerns performance retention outside the training distribution. A reader comparing methods should ask which of the two a given configuration is optimizing.

Transfer beyond Prolog-shaped tasks stays empirical

The more interesting test is whether TLP improves reasoning the model must do alone, without a solver at inference time. The paper evaluates on tasks that resist pure symbolic treatment because they need implicit common-sense knowledge or reasoning under uncertainty, and reports encouraging transfer to CommonsenseQA and StrategyQA. The authors are explicit that this transfer is empirical: they offer no theoretical account of when reasoning learned from verifiable problems should carry over to tasks requiring implicit knowledge or probabilistic judgment.

The training distribution is biased by construction toward problems whose answers Prolog can verify, which means tasks with explicit logical or arithmetic structure. The paper states it cannot rule out weaker transfer on benchmarks farther from that distribution.

Accuracy gains do not prove deeper reasoning

The paper's central limitation is interpretive. Its evidence is behavioral: higher accuracy after training on Prolog-verified trajectories is consistent with stronger reasoning competence, but also with the model having learned a cleaner output format rather than a different way of arriving at answers. The authors note the same ambiguity has been raised for chain-of-thought methods generally, where a generated rationale need not faithfully reflect the underlying computation.

Their use of "intrinsic reasoning" is therefore narrow and should be read that way: the model reaches correct answers without calling an external solver at inference time. It is not a claim about internal mechanism. Separating style acquisition from a genuine change in reasoning behavior is left open, and the authors say the work does not aim at state-of-the-art results on task-specific datasets but at improving the model's internal reasoning capability.

The priority is trajectory quality, not solver access

The paper's most decision-relevant comparison is between learning from verified trajectories and learning from unverified ones. TLP's advantage over multi-path baselines and its occasional edge over ground-truth-trajectory fine-tuning point to the verification step, not the number of sampled rationales, as the source of improvement; the Prolog engine is used to build training data, not to answer questions at test time.

That reframes the practical question. The relevant threshold is whether a task can be formalized well enough for Prolog to verify a derivation, since translation validity bounds the pipeline and the training distribution skews toward explicit logical and arithmetic structure. Where that condition holds, the reported 8B results support adopting verified-trajectory imitation with model averaging to protect retention; where a task depends on implicit knowledge or probabilistic judgment, the paper offers encouraging but explicitly empirical transfer, and the behavioral evidence cannot yet distinguish better reasoning from better-formatted answers.

Sources used in this answer