Language Models as Compilers: Simulating Pseudocode Execution Improves Algorithmic Reasoning in Language Models (2404.02575v1)

Abstract: Algorithmic reasoning refers to the ability to understand the complex patterns behind the problem and decompose them into a sequence of reasoning steps towards the solution. Such nature of algorithmic reasoning makes it a challenge for LLMs, even though they have demonstrated promising performance in other reasoning tasks. Within this context, some recent studies use programming languages (e.g., Python) to express the necessary logic for solving a given instance/question (e.g., Program-of-Thought) as inspired by their strict and precise syntaxes. However, it is non-trivial to write an executable code that expresses the correct logic on the fly within a single inference call. Also, the code generated specifically for an instance cannot be reused for others, even if they are from the same task and might require identical logic to solve. This paper presents Think-and-Execute, a novel framework that decomposes the reasoning process of LLMs into two steps. (1) In Think, we discover a task-level logic that is shared across all instances for solving a given task and then express the logic with pseudocode; (2) In Execute, we further tailor the generated pseudocode to each instance and simulate the execution of the code. With extensive experiments on seven algorithmic reasoning tasks, we demonstrate the effectiveness of Think-and-Execute. Our approach better improves LMs' reasoning compared to several strong baselines performing instance-specific reasoning (e.g., CoT and PoT), suggesting the helpfulness of discovering task-level logic. Also, we show that compared to natural language, pseudocode can better guide the reasoning of LMs, even though they are trained to follow natural language instructions.

LLMs as Compilers: Enhancing Algorithmic Reasoning through Pseudocode Execution Simulation

Introduction

The paper explores the intersection of algorithmic reasoning and LLMs, addressing a significant challenge: the ability of LLMs to understand complex problem patterns and decompose these into executable reasoning steps. Despite their promising capabilities in various reasoning tasks, LLMs struggle with tasks that demand intricate algorithmic reasoning due to the complexity and length of the necessary reasoning sequence. To mitigate this, the paper introduces a novel framework, Think-and-Execute, which improves LLMs' algorithmic reasoning by simulating the execution of pseudocode, offering a structured approach to problem-solving.

Think-and-Execute Framework

The crux of the Think-and-Execute framework lies in its bifurcated approach: the Think phase, which involves generating a generalized, task-level pseudocode that encapsulates the underlying logic for solving a task, and the Execute phase, where the model simulates the execution of this pseudocode tailored to each instance of the problem. This framework not only aids in discovering the logic behind solving a given task but also paves the way for executing this logic via simulation, which considerably enriches the reasoning process of LLMs.

Think Phase

The Think phase is pivotal for distilling a task-level logic that transcends individual instances. By leveraging examples, an LLM formulates a pseudocode that outlines a generalized approach to the task. This pseudocode, unlike instance-specific code, remains applicable across different scenarios of the same problem category, enabling reusability and efficiency in problem-solving.

Execute Phase

In the Execute phase, the model engages in simulating the execution of the task-level pseudocode. This process involves dynamically generating reasoning steps and outcomes based on the pseudocode logic, tailored to each specific problem instance. The focus on executing pseudocode, as opposed to direct code execution or rationale generation in natural language, showcases an innovative path towards enhancing algorithmic reasoning in LLMs.

Empirical Evaluation and Results

The paper’s empirical evaluation spanned seven algorithmic reasoning tasks, revealing the superiority of the Think-and-Execute framework over existing methods such as Zero-shot Chain-of-Thought and Program-of-Thought prompts. Notably, the framework demonstrated remarkable improvements across varied tasks, underscoring the efficacy of task-level logic discovery and pseudocode simulation in bolstering LLMs' reasoning capabilities.

Implications and Future Directions

The introduction of the Think-and-Execute framework signifies a pivotal step forward in the field of algorithmic reasoning for LLMs. By abstracting the task-level logic through pseudocode and simulating its execution, this approach not only enriches the model's problem-solving aptitude but also hints at broader applicability across diverse reasoning tasks beyond algorithmic reasoning. Looking ahead, further exploration in tailoring the framework for complex, multi-step reasoning tasks holds the promise of unlocking new frontiers in artificial intelligence and computational linguistics.

Conclusion

This paper presents an innovative framework that fundamentally rethinks the approach to enhancing algorithmic reasoning in LLMs. Through the lens of the Think-and-Execute framework, it lays down a concrete foundation for future research aimed at unlocking the full potential of LLMs in understanding and executing complex reasoning tasks. As we move forward, the fusion of algorithmic logic with LLMs' innate capabilities could redefine the boundaries of what artificial intelligence can achieve.