Pith. sign in

REVIEW 5 major objections 4 minor 2 cited by

GraphOTTER: Evolving LLM-based Graph Reasoning for Complex Table Question Answering

T0 review · 5 major / 4 minor · reviewed 2026-08-12 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read GraphOTTER claims that complex table question answering is best done by converting the table into an undirected graph and having a language model reason step by step with graph actions, and reports consistent gains over implicit…

desk verdict A solid, clearly-written empirical paper on LLM graph reasoning for complex table QA; the AIT-QA filtering is a real but fixable wrinkle. read the letter →

arxiv 2412.01230 v1 pith:V5SM4CHJ submitted 2024-12-02 cs.CL

Qianlong Li , Chen Huang , Shuai Li , Yuanxin Xiang , Deng Xiong , Wenqiang Lei This is my paper · ORCID
classification cs.CL
keywords complextablequestionansweringgraphreasoninglargelanguagemodelstracerepresentationself-inferredheadersHiTabAIT-QA
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

GraphOTTER is a method for answering questions about complex tables that converts the table into an undirected graph—cells are nodes, same-row/same-column cells are edges—and then has a language model reason step by step over that graph using a small set of actions (visit a node, get neighbours, get shared neighbours, answer). The paper's central claim is that this explicit, traceable reasoning is more accurate than feeding the whole table into a prompt, because it lets the model ignore irrelevant cells. Across the HiTab and AIT-QA benchmarks and two LLM backbones, the method reports an average gain of +4.77% over the best baseline. The paper argues the gain comes from filtering out irrelevant information, and shows the model uses far fewer table cells when producing answers.

What carries the argument

The central object is an undirected graph G=(N,E,V) built from the table, where each node is a triple (row index, column index, cell value), merged cells have sets of indices, and edges connect cells in the same row or column with a label saying which. Reasoning is driven by a Thought-Action-Update loop: the LLM maintains a reasoning trace (the visited nodes and their connections), selects one of four actions—VisitNode, GetAllNeighbours, GetSharedNeighbours, AnswerQuestion—executes it against the graph, and updates the trace. This machinery lets the model expand only the relevant neighbourhood of cells and decide when it has enough information to answer.

What would settle it

Run GraphOTTER on a held-out set of complex tables whose hierarchical headers are not aligned with simple row/column adjacency (for example, headers that apply diagonally or span only part of a row/column), keeping the same prompt and action design; if accuracy falls to or below the best implicit baseline on that set, the claim that the graph representation generalizes beyond header positions would be falsified.

Watch

Extended reading notes

Core claim

On its own terms, the paper's discovery is that explicit graph-based reasoning is a better inductive bias for complex table QA than implicit whole-table prompting. GraphOTTER treats header and data cells uniformly as nodes, so it does not need pre-annotated headers or assumptions about header location. The step-by-step actions and the reasoning trace—the growing subgraph of visited nodes—turn a complex table into a navigable structure, and the final answer is generated from only the local state, not the entire graph. The paper shows this outperforms one-shot and iterative implicit baselines as well as the iterative explicit Chain-of-Table method on both datasets and both backbones.

Load-bearing premise

The undirected same-row/same-column graph is assumed to preserve enough of the table's semantic structure—including merged cells and flexible header locations—for the LLM to reason accurately without explicit header annotations; the paper does not validate this independently of its aggregate accuracy results, which themselves rely on a filtered AIT-QA test set.

Editorial extensions

If this is right

  • If the central claim is correct, explicit graph-based reasoning becomes a strong default for complex table QA, especially where headers are not at the top or left.
  • The reasoning trace provides an inspectable explanation of which cells led to the answer, enabling human verification of the model's reasoning path.
  • The method's few iterations compared to ReAct-style baselines suggest it is cost-effective for iterative reasoning, despite being iterative itself.
  • The self-inferred header mechanism implies the method transfers to new table layouts without annotation, which is a practical advantage over header-dependent baselines.
  • The sensitivity to trace initialization (4–8 cells) indicates that a hybrid retrieval/model-selection step is important for performance.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The graph representation with only same-row/same-column edges may not capture hierarchical header semantics in all complex tables; a directed or hypergraph representation might be needed for tables where headers span multiple columns in non-rectangular ways.
  • The filtered AIT-QA test set (tables where header positions cannot be reconstructed) means the reported gains may not hold on the full AIT-QA distribution; this is a caveat the reader should weigh.
  • A natural extension is to combine one-shot and iterative reasoning to reduce LLM calls, as the paper itself suggests, and to add n-hop neighbour actions for longer-range reasoning.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

5 major / 4 minor

Summary. The paper proposes GraphOTTER, a method for complex table question answering that converts a table into an undirected graph whose nodes are cells and whose edges encode same-row and same-column relations, then prompts an LLM to reason step-by-step using four actions (VisitNode, GetAllNeighbours, GetSharedNeighbours, AnswerQuestion). A reasoning trace is initialized with a small set of retrieved nodes and dynamically updated as the LLM performs actions. The authors evaluate GraphOTTER on HiTab and AIT-QA using Gemini-1.5-flash and Qwen2-72B-Instruct, compare it against one-shot implicit, iterative implicit, and iterative explicit baselines, and include ablations on graph-vs-implicit reasoning, known-vs-self-inferred headers, iteration efficiency, and initialization size. The central claim is that explicit graph reasoning improves complex-table QA by filtering out irrelevant information and by not requiring pre-annotated headers.

Significance. If the reported results hold, the paper makes a useful contribution to complex-table QA: it offers a concrete way to make LLM reasoning explicit over a graph representation, it releases code and prompts, and its ablations support the view that combining graph representations with explicit reasoning helps. The method is clearly described and the action set is simple enough to be adapted by others. However, the evaluation has several load-bearing issues: the AIT-QA experiments are run on a heavily filtered subset that is not clearly labeled as such in the main text, the headline performance gains are not reproducible from the reported table, and there is no variance or significance analysis for several very small margins. These issues weaken the support for the claim that GraphOTTER consistently outperforms the best baselines across benchmarks.

major comments (5)
  1. [Section 4.2 and Appendix B, Table 6] The main text presents Table 2 as results on 'AIT-QA' and draws the headline conclusion that GraphOTTER outperforms all baselines there, but the experiments use only 80 tables and 367 QA pairs after removing AIT-QA tables whose header cells cannot be positionally reconstructed without annotations. This removal is not a random subsample: it preferentially drops tables with the most flexible or ambiguous header structures, which are precisely the cases GraphOTTER was designed to handle. The relative comparison is internally coherent because all methods are evaluated on the same subset, but the external claim about AIT-QA as a benchmark is not established. Please report the filtering criterion and counts in the main text, and evaluate on the full AIT-QA test set or on a justified random subset that preserves the hard cases.
  2. [Abstract and Section 4.2, Table 2] The claimed gains are not reproducible from Table 2. The abstract states an average gain of +4.77% over the best baseline; Section 4.2 states that GraphOTTER surpasses MIX-SC by an average of +9.07% on HiTab and +1.63% on AIT-QA. Computing from Table 2, GraphOTTER over MIX-SC averages +1.66% on HiTab and +6.03% on AIT-QA, and +3.43% if the best per-cell baseline is used instead. Please correct the arithmetic or state clearly what averaging protocol produces the quoted numbers; as written, the headline number is not supported by the reported table.
  3. [Table 2 and Section 4.2] All results are single-run point estimates with no variance, confidence intervals, or significance tests. Several claimed wins are very small (for example, on Qwen2, HiTab EM 73.74 vs 73.42 and LLM Eval 77.37 vs 77.08), so the statement that GraphOTTER 'consistently outperforms' all baselines rests on differences that may be within run-to-run noise. Please report multiple seeds, bootstrap intervals, or a significance test for at least the main comparisons, especially given that the LLM evaluator itself introduces additional variance.
  4. [Section 4.4, Figure 5] The top-K initialization size is selected after inspecting sensitivity curves computed on the same test sets used for the main results, and the paper then states that all experiments use K=8 'without further tuning.' Because Figure 5 shows that performance varies with K, selecting K from test-set performance is a form of test-set tuning and can inflate the reported numbers. Please perform this sensitivity analysis on a validation split, or report the selection as a tuned hyperparameter and soften the 'without further tuning' claim.
  5. [Appendix A.1 and Table 2] The baseline comparison is not fully controlled for header information. Only TableParser is explicitly run with header cells removed to simulate the real-world scenario, while the other baselines use their official code or prompts that assume headers at the top or left of the table. Since GraphOTTER's advantage is partly that it does not need header annotations, this asymmetry may favor GraphOTTER. Please report baselines both with and without header annotations, or justify why the official header assumptions are appropriate for all tables in both datasets.
minor comments (4)
  1. [Section 4.3, Figure 3] The axes of Figure 3 are confusing: the x-axis is labeled 'LLM Eval (%)' while the y-axis appears to be 'Average cell utilization rate per question (%)', and the figure also contains oddly placed text fragments. Please redraw the figure with clear axis labels and a proper legend.
  2. [Section 4.4, Figure 4] Figure 4 has duplicated and truncated labels (for example, 'Gemini on AIT-QA' appears twice and 'Agerave' should be 'Average'), and the numerical annotations near the bars are difficult to read. Please clean up the figure formatting.
  3. [Tables 3 and 5] The header-related analysis uses AIT-QA annotations, but the paper does not say this explicitly in the main text; please state that the HRQ/HUQ split is available only for AIT-QA. Also, in Table 3 the Gemini-1.5 HRQ result for TableParser (71.05) is actually higher than GraphOTTER (69.74); the text should acknowledge this exception rather than saying GraphOTTER achieves promising results on both question types without qualification.
  4. [Section 3.3, Table 1] The VisitNode and GetAllNeighbours actions can return multiple candidate nodes for duplicate cell values; the paper mentions presenting structural information to the LLM, but it would be helpful to specify how ties are resolved when the LLM query matches many nodes with identical content.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: GraphOTTER's central claims rest on external benchmark comparisons, and no step in the derivation reduces to its own inputs or to a load-bearing self-citation chain.

full rationale

GraphOTTER's contribution is an algorithmic pipeline evaluated against external benchmarks (HiTab and AIT-QA) with two LLM backbones. The undirected graph representation and the set of intermediate reasoning actions are design choices, not quantities derived from the benchmark results. No equation defines the method's output in terms of the evaluation numbers, and no fitted parameter is renamed as a prediction. The only tunable choice, the top-K initialization for the reasoning trace, is presented through a sensitivity analysis and then fixed to up to 8 nodes for all experiments; even if this constitutes mild test-set tuning, it does not make the accuracy claims circular. The filtered AIT-QA subset described in Appendix B is an external-validity concern, not a circularity, because all baselines are rerun on the same subset and the relative comparison remains internally coherent. Self-citations in the paper appear only as future-work pointers and are not load-bearing for the main results. Therefore, the derivation chain is self-contained and no circular step can be exhibited.

Assumptions & free parameters 1 free parameters · 4 assumptions · 0 invented entities

The paper introduces no new physical or latent entities. Its contributions are procedural: a table-to-graph conversion, a set of graph reasoning actions, and a reasoning trace mechanism. The free parameters are limited to the initial node count selection, which is a hyperparameter. The axioms are the representational and evaluator assumptions listed above.

free parameters (1)
  • max_initial_nodes_K = 8 (maximum)
    Number of cells selected to initialize the reasoning trace. Chosen after sensitivity analysis in Figure 5; paper recommends 4-8 and uses 8 for all experiments, described as 'without further tuning'.
assumptions (4)
  • domain assumption Same-row and same-column adjacency in a table is sufficient to capture all semantic relationships needed to answer questions, including merged-cell and hierarchical-header semantics.
    This is the core representational assumption in Section 3.2. No formal justification is given; it is validated only by downstream accuracy.
  • domain assumption The LLM can infer which nodes are headers from the graph structure and question context without explicit annotations.
    GraphOTTER treats header and data cells identically (Section 3.2) and relies on the Thought step to infer headers. The paper tests this via an ablation with known headers, showing comparable performance, but the inference itself is assumed reliable.
  • domain assumption The gte-base retriever returns a reasonable candidate set such that intersecting it with the LLM's selected cells produces a useful initial trace.
    The initialization uses the intersection of retriever (gte-base) and LLM outputs (Appendix A.3.1). If the retriever is poor, the initialization may be degraded; no analysis of retriever quality is given.
  • domain assumption The LLM-based evaluator (CompareGPT, Gemini) provides reliable accuracy assessments comparable to human judgment.
    Evaluation uses an LLM judge (Appendix A.2), which may have systematic biases. This is a common practice but still an assumption.

how reviews work

0 comments
Cite this review

Pith. "Pith review of GraphOTTER: Evolving LLM-based Graph Reasoning for Complex Table Question Answering." pith.science (2026). https://pith.science/paper/V5SM4CHJ

@misc{pith2026241201230,
  author       = {Pith},
  title        = {Pith review of: GraphOTTER: Evolving LLM-based Graph Reasoning for Complex Table Question Answering},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/V5SM4CHJ}},
  note         = {Machine review of arXiv:2412.01230}
}
read the original abstract

Complex Table Question Answering involves providing accurate answers to specific questions based on intricate tables that exhibit complex layouts and flexible header locations. Despite considerable progress having been made in the LLM era, the reasoning processes of existing methods are often implicit, feeding the entire table into prompts, making it difficult to effectively filter out irrelevant information in the table. To this end, we propose GraphOTTER that explicitly establishes the reasoning process to pinpoint the correct answers. In particular, GraphOTTER leverages a graph-based representation, transforming the complex table into an undirected graph. It then conducts step-by-step reasoning on the graph, with each step guided by a set of pre-defined intermediate reasoning actions. As such, it constructs a clear reasoning path and effectively identifies the answer to a given question. Comprehensive experiments on two benchmark datasets and two LLM backbones demonstrate the effectiveness of GraphOTTER. Further analysis indicates that its success may be attributed to the ability to efficiently filter out irrelevant information, thereby focusing the reasoning process on the most pertinent data. Our code and experimental datasets are available at \url{https://github.com/JDing0521/GraphOTTER}.

Figures

Figures reproduced from arXiv: 2412.01230 by the authors.

Figure 1
Figure 1. Example of complex table QA. Header cells [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Overview of GraphOTTER. It first transforms the table into a graph representation (For clarity, this graph [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Average percentage of cells/nodes required [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (12 more)
Figure 4
Figure 4. Figure 4: Illustration of the iteration efficiency of different methods. GraphOTTER achieves superior performance [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: Impact of reasoning trace initialization (i.e., [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: Illustration of the graph reasoning of GraphOT [PITH_FULL_IMAGE:figures/full_fig_p013_6.png]
Figure 7
Figure 7. Figure 7: Prompt for TableReasoner Suppose you are an expert in statistical analysis. You will be given a table described in a special format. Your task is to answer the questions based on the content of the table. The table is described as follows: 1. The title means the title …
Figure 8
Figure 8. Figure 8: Prompt for TableParser Suppose you are an expert in statistical analysis. You will be given a table described in a special format. Your task is to answer the Question based on the content of the table. Graph Definition : We consider each cell in the table as a node in …
Figure 9
Figure 9. Figure 9: System instruction for GraphOTTER’s graph reasoning [PITH_FULL_IMAGE:figures/full_fig_p015_9.png]
Figure 10
Figure 10. Figure 10: Prompt and system instruction for GraphOTTER’s reasoning trace initialization. Subsequently, we [PITH_FULL_IMAGE:figures/full_fig_p016_10.png]
Figure 11
Figure 11. Figure 11: Thought Step Prompt of GraphOTTER. Note that the Update Step does not rely on prompt. [PITH_FULL_IMAGE:figures/full_fig_p017_11.png]
Figure 12
Figure 12. Figure 12: Action Step Prompt of GraphOTTER. Note that the Update Step does not rely on prompt. [PITH_FULL_IMAGE:figures/full_fig_p018_12.png]
Figure 13
Figure 13. Figure 13: Answer Generation Prompt of GraphOTTER [PITH_FULL_IMAGE:figures/full_fig_p019_13.png]
Figure 14
Figure 14. Figure 14: A example of Reasoning Trace and Interaction History of GraphOTTER [PITH_FULL_IMAGE:figures/full_fig_p020_14.png]
Figure 15
Figure 15. Figure 15: LLM Evaluation Prompt [PITH_FULL_IMAGE:figures/full_fig_p021_15.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Beyond Natural Language Plans: Structure-Aware Planning for Query-Focused Table Summarization

    cs.CL 2025-07 conditional novelty 4.0 of 10

    SPaGe uses structured TaSoF plans and graph-parallel SQL execution to improve query-focused table summarization, outperforming most prior models on FeTaQA, QTSumm, and QFMTS datasets.

  2. Synergizing LLMs and Knowledge Graphs: A Novel Approach to Software Repository-Related Question Answering

    cs.SE 2024-12 conditional novelty 4.0 of 10

    An LLM plus a repository knowledge graph answers software repository questions with 84% accuracy when few-shot chain-of-thought prompting is added, outperforming an intent-based bot and web-search GPT-4o.

Reference graph

Works this paper leans on

31 extracted references · 29 canonical work pages · cited by 2 Pith papers

  1. [1]

    The title means the title of the table

    work page

  2. [2]

    For examples : The tuple (7, 0, 416) represents a cell at row 7, column 0, with a value of 416

    We represent cell tuples as (C1 , C2 , C3), where C1 denotes the row , C2 denotes the column , and C3 denotes the content . For examples : The tuple (7, 0, 416) represents a cell at row 7, column 0, with a value of 416. Make sure you read and understand these instructions carefully . Let 's think step by step as follows and give full play to your expertis...

    work page

  3. [3]

    You MUST answer each question in the format below line by line ( Note : Keep your answer concise ):

    Perform statistical , calculation , sorting , grouping , or other operations on the tuples you selected before to extract useful information based on the question 's requirements . You MUST answer each question in the format below line by line ( Note : Keep your answer concise ):

    work page

  4. [4]

    Thought step { step }: { your thought }

    ** Avoid Redundant Calculations **: Before performing any calculations or operations , first check if the needed information is already available in the graph . If so , directly use this information . Table : { Table } Question : { Question } { Reasoning Trace } { Interaction History } Please integrate all the current information to output your Thought st...

    work page

  5. [5]

    Clearly understand the question and the information needed to answer the question to determine the necessary information to extract

    work page

  6. [6]

    These tuples help you skip a lot of operations )

    Have a comprehensive understanding of the data in the table , including the meaning , data types , and formats of each column and row tuples ( Note : There are usually summative tuples in the table , such as all , combine , total , sum , average , mean , etc. These tuples help you skip a lot of operations )

    work page

  7. [8]

    Cell : The cell tuples most relevant to the answer

    work page

  8. [9]

    Operation : the operation you performed on the tuples you selected

    work page

Show all 31 references
  1. [10]

    I don 't know

    Answer : your answer (A number , noun , phrase , or set of data ). And if the answer is not contained within the context , say "I don 't know ". Title : { TABLE_TITLE_HERE } Cells : { TABLE_NON_HEADER_HERE } Q: { QUSTION_HERE } A: Figure 8: Prompt for TableParser Suppose you a...

  2. [11]

    ** Understand the Question **: Clearly understand the Question and the information needed to answer the Question to determine the necessary information to extract

  3. [12]

    ** Analyze the Data Structure **: Have a comprehensive understanding of the data in the Table , including the meaning , data types , and formats of each cell tuples

  4. [13]

    ** Select Relevant Data **: Based on the Question , identify the most relevant cell tuples . ** Note :** Pay special attention to the header cell tuples in the Table , as they are often more relevant to the Question 's semantics and can help in identifying the related evidence...

  5. [14]

    Outputs cell tuples in descending order of relevance

  6. [15]

    tuple ": tuple ,

    Using this JSON schema : Tuple = {" tuple ": tuple , " explanation ": str }. Return a `list [ Tuple ] `. Figure 10: Prompt and system instruction for GraphOTTER’s reasoning trace initialization. Subsequently, we identify the intersection of the results generated by this prompt...

  7. [17]

    Action

    In the " Action " step , you can call the following functions to get more node information from the graph : a. VisitNode ( query ): Retrieve the node from the graph that is semantically closest to the keyword 'query '( given as a str). Note : 'query ' cannot be the known Cell ...

  8. [20]

    (** Note :** Some cells may have identical Cell Content , so avoid greedy searches when necessary ; Focus on the most relevant and directly related data to the Question at hand .)

    ** Select Relevant Data **: Based on the Question , identify the most relevant nodes . (** Note :** Some cells may have identical Cell Content , so avoid greedy searches when necessary ; Focus on the most relevant and directly related data to the Question at hand .)

  9. [22]

    Thought

    In the " Thought " step , thoroughly examine the question and the existing data . Determine if the current data is sufficient to answer the question : a. If the existing information is sufficient , proceed the " Action " step and call the " AnswerQuestion " function to give th...

  10. [23]

    Action

    In the " Action " step , you can call the following functions to get more node information from the graph : a. VisitNode ( query ): Retrieve the node from the graph that is semantically closest to the keyword 'query '( given as a str). Note : 'query ' cannot be the known Cell ...

  11. [24]

    ** Understand the Question **: Clearly understand the Question , clarify the relationships between the existing data , and organize the information needed to answer the Question

  12. [25]

    all", " combine

    ** Analyze the Data Structure **: Have a comprehensive understanding of the data in the graph , including the meaning , data types , and formats of each nodes . ** Note :** Pay special attention to some ** summative or aggregated nodes ** (e.g., "all", " combine ", " total ", ...

  13. [26]

    ** Select Relevant Data **: Based on the Question , identify the most relevant nodes

  14. [27]

    If so , directly use this information

    ** Avoid Redundant Calculations **: Before performing any calculations or operations , first check if the needed information is already available in the graph . If so , directly use this information

  15. [28]

    Ensure that the final answer directly addresses the question , using the most relevant and accurate data from the graph

    ** Synthesize the Answer **: Use the selected data to construct a clear and concise answer . Ensure that the final answer directly addresses the question , using the most relevant and accurate data from the graph . You MUST answer each question step by step as follows ( Note :...

  16. [29]

    Cell : The nodes most relevant to the answer

  17. [30]

    Operation : the operation you performed on the nodes you selected

  18. [31]

    Explanation : your explanation

  19. [32]

    cells " : list [str],

    Answer : your final answer . And if you need to extract relevant Cell Content from the graph as answer , do not add any units , symbols , or other explanatory text . Ensure that the extracted Content matches the original Cell Content in the graph exactly . Table : { table } Qu...

  20. [33]

    Observation Step 1:

    Function : GetSharedNeighbours ((4 , 0, 'brampton ') , (0, 2, 'as a percent of total female population in each cma/ municipality ')), Explanation : To find the percentage of the total female population in Brampton , we need to get the shared neighbors of the nodes (4, 0, 'bram...

  21. [34]

    Ground - truth Answer

    The result of GetSharedNeighbours ((4 , 0, 'brampton ') , (0, 2, 'as a percent of total female population in each cma/ municipality ')) is: [(4 , 0, 'brampton ') , (0, 2, 'as a percent of total female population in each cma/ municipality ')] has the following shared neighbors ...

  22. [2021]

    id" : "tab −2

    Finqa: A dataset of numerical reasoning over financial data.arXiv preprint arXiv:2109.00122. Zhoujun Cheng, Haoyu Dong, Zhiruo Wang, Ran Jia, Jiaqi Guo, Yan Gao, Shi Han, Jian-Guang Lou, and Dongmei Zhang. 2022. HiTab: A hierarchical table dataset for question answering and na...

    2022 arXiv

  23. [2024]

    Wenhu Chen

    Can llms perform structured graph reasoning? Preprint, arXiv:2402.01805. Wenhu Chen. 2022. Large language models are few (1)-shot table reasoners. arXiv preprint arXiv:2210.06710. Yue Chen, Dingnan Jin, Chen Huang, Jia Liu, and Wen- qiangLei.2023. TRAVEL:Tag-awareconversationa...

    2022 arXiv

Pith tools

Reviewed August 12, 2026 · model on record in the stance chip above.