Technical Summary: Skill-Augmented Table Graph Reasoning for Operation-wise Table Question Answering

1. Problem Definition and Motivation

Table Question Answering (TableQA) requires models to reason over tabular data to answer natural language queries. While Large Language Models (LLMs) have shown promise, existing research suffers from two primary limitations:

1. Coarse-Grained Evaluation: Current benchmarks evaluate performance solely through overall accuracy. This obscures a critical disparity: LLMs excel at simple "Conditional Lookup" (cell-level retrieval) but struggle significantly with complex operations requiring cross-row reasoning, such as Comparison, Extremum, Aggregation, and Arithmetic.
2. Modeling Bottlenecks:
   • Structural Disruption: Existing methods typically linearize tables into flat text sequences. This disrupts inherent row-column-cell structures and induces the "lost-in-the-middle" phenomenon, where LLMs neglect critical intermediate evidence in long contexts.
   • Reasoning from Scratch: Prevailing approaches infer each question independently without leveraging historical reasoning patterns. This prevents the reuse of successful strategies or the avoidance of common failure modes across similar operation types.

To address these issues, the authors introduce the Operation-wise TableQA task, which categorizes questions into five core operations (Conditional Lookup, Comparison, Extremum, Aggregation, Arithmetic) to enable fine-grained diagnosis of model capabilities.

2. Methodology: SkillTGR Framework

The authors propose Skill-augmented Table Graph Reasoning (SkillTGR), a framework designed for self-evolving structured reasoning. It consists of three core components:

A. Attributed Table Graph Construction

Instead of linearization, SkillTGR transforms tables into attributed graphs ($G = \{V, E\}$) to preserve structural semantics:

• Nodes: Includes a global Meta node (table caption), Row nodes (representing tuples), and Cell nodes (representing unique values within columns).
• Edges: Connects the Meta node to all Row nodes ("has" relation) and Row nodes to Cell nodes, annotated with column headers.
• Benefit: This structure explicitly maintains row-column-cell relationships, mitigating the "lost-in-the-middle" issue and enabling efficient value-anchored retrieval across multiple rows.

B. Dynamic Graph Traversal Reasoning

SkillTGR employs a multi-agent system (Planner, Executor, Reasoner) to traverse the graph:

• Planner: Selects graph operators (e.g., Expand, Navigate, Anchor, Cluster, Rank) to plan a dynamic reasoning chain.
• Executor: Executes these operators to retrieve minimal yet sufficient evidence subgraphs.
• Reasoner: Performs structured graph traversal reasoning over the retrieved subgraph using Chain-of-Thought to derive the final answer.
  This process allows for adaptive, step-by-step evidence retrieval rather than processing the entire table as a block.

C. Skill-Augmented Self-Evolution

To break the "reason-from-scratch" limitation, SkillTGR introduces a hierarchical SkillBank:

• Skill Extraction: A "Mentor" agent distills historical reasoning trajectories into reusable skills. It categorizes trajectories as Successful (extracting strategic patterns) or Failed (summarizing root causes of errors).
• Hierarchical Organization: The SkillBank is structured by Operation Type (e.g., Aggregation) and Trajectory Status (Successful vs. Failed).
• Contrastive Augmentation: During reasoning, the system retrieves top-$k$ successful and failed skills relevant to the current question.
  • Successful skills act as positive anchors to guide the Planner and Executor.
  • Failed skills act as negative constraints to prevent recurring errors.
• Continuous Evolution: The SkillBank is updated via a Manager agent that merges, adds, or discards skills based on completeness and portability, enabling the system to evolve over time without parameter updates.

3. Key Contributions

1. Operation-wise TableQA Task: The first investigation of TableQA through a fine-grained lens, introducing two refined datasets (WikiTQ-ow and TabFact-ow) annotated with five core operation types to reveal LLM reasoning disparities.
2. SkillTGR Framework: A novel architecture that combines attributed graph modeling with a hierarchical SkillBank. It enables structure-aware evidence retrieval and contrastive augmented reasoning, facilitating continual self-evolution.
3. Empirical Validation: Extensive experiments demonstrating that SkillTGR achieves state-of-the-art performance while significantly improving efficiency.

4. Experimental Results

Experiments were conducted on WikiTQ-ow and TabFact-ow using Qwen3.5-9B and Ministral3-8B backbones.

• Performance: SkillTGR achieved an average improvement of 5.91% in overall accuracy and 6.03% in operation-wise accuracy over competitive baselines (including Table-Critic and Chain-of-Table).
• Complex Operations: The model showed particular strength in complex operations (Comparison, Extremum, Aggregation, Arithmetic), where baselines often failed due to structural loss.
• Efficiency: SkillTGR reduced token consumption by 19.76% and inference latency by 27.64% compared to iterative refinement baselines, as it avoids redundant full-table processing and leverages pre-compiled skills.
• Scalability: The performance gap between SkillTGR and baselines widened significantly on long tables (Row $\ge$ 50 or Token $\ge$ 4k), confirming the robustness of graph-based reasoning against the "lost-in-the-middle" issue.
• Ablation Studies: Removing the graph construction, the SkillBank, or the contrastive augmentation modules resulted in significant performance drops, validating the necessity of each component.

5. Significance and Claims

The paper claims that SkillTGR addresses the fundamental limitations of current TableQA approaches by shifting from linear text processing to structured graph reasoning and from isolated inference to experience-augmented self-evolution.

• Modest Claims: The authors explicitly state that their method reduces reliance on the intrinsic reasoning capabilities of the LLM backbone by decomposing reasoning into explicit, skill-guided operations. This results in a better trade-off between performance and robustness, particularly for smaller models (e.g., Ministral3-8B).
• Transparency: The self-evolution process is described as transparent and controllable, as skills are explicitly managed (added, merged, discarded) rather than learned implicitly through parameter updates.
• Generalizability: The framework is presented as a plug-and-play solution that can be applied to diverse table reasoning tasks, offering a pathway to continual improvement without retraining the base model.

The authors conclude that by revealing operation-wise disparities and providing a structured, skill-based solution, SkillTGR offers a more effective and efficient paradigm for complex table reasoning.