Pseudocode-Injection Magic: Enabling LLMs to Tackle Graph Computational Tasks

TL;DR

The paper addresses the high error rate and prohibitive cost of using LLMs for graph tasks by introducing PIE, a three-phase framework that splits problem understanding (LLMs) from graph-structure execution (interpreter) and enhances code generation through pseudocode-injection. By guiding LLMs with standardized pseudocode and validating generated code via low-cost trials, PIE achieves high accuracy across nine graph tasks (including NP-complete problems) while dramatically reducing inference costs and enabling reuse of produced code. Experimental results on polynomial-time and NP-complete tasks show PIE outperforms baselines in both accuracy and efficiency, with clear gains in feasibility and reduced approximation error. The approach offers a practical path to scalable, cost-efficient LLM-based graph computation, with broad implications for real-world graph analytics where latency and resource use matter.

Abstract

Graph computational tasks are inherently challenging and often demand the development of advanced algorithms for effective solutions. With the emergence of large language models (LLMs), researchers have begun investigating their potential to address these tasks. However, existing approaches are constrained by LLMs' limited capability to comprehend complex graph structures and their high inference costs, rendering them impractical for handling large-scale graphs. Inspired by human approaches to graph problems, we introduce a novel framework, PIE (Pseudocode-Injection-Enhanced LLM Reasoning for Graph Computational Tasks), which consists of three key steps: problem understanding, prompt design, and code generation. In this framework, LLMs are tasked with understanding the problem and extracting relevant information to generate correct code. The responsibility for analyzing the graph structure and executing the code is delegated to the interpreter. We inject task-related pseudocodes into the prompts to further assist the LLMs in generating efficient code. We also employ cost-effective trial-and-error techniques to ensure that the LLM-generated code executes correctly. Unlike other methods that require invoking LLMs for each individual test case, PIE only calls the LLM during the code generation phase, allowing the generated code to be reused and significantly reducing inference costs. Extensive experiments demonstrate that PIE outperforms existing baselines in terms of both accuracy and computational efficiency.

Figures (9)

• Figure 1: Nine graph tasks and the overview of our framework. In "Problem Understanding" phase, our approach allocates the understanding of task description and graph structure to LLM and Python interpreter respectively, which reduces the probability of errors arising from graph reading. In phase "Prompt Design", we design three types of prompts, including pseudocode extracted from papers, to guide the LLM to generate efficient code. Finally, in "Code Generation and Execution" phase, we utilize a small-scale dataset and perform multiple trials-and-errors to ensure LLM's output code to run correctly, which is then employed on other large-scale graphs.
• Figure 2: Approximation ratio comparison of various methods on different NP-complete tasks. Lower is better.
• Figure 3: Feasible rate comparison of various methods on different NP-complete tasks. Higher is better.
• Figure 4: Time cost comparison for a single call to LLMs, averaging small and large graphs.
• Figure 5: Code generated by LLMs without pseudocode.