Pith. sign in

REVIEW 3 major objections 6 minor 32 references

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

T0 review · 3 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read Structured plans beat natural-language plans in query-focused table summarization

desk verdict Solid incremental contribution that overstates its results and leaves the key format comparison unverifiable. read the letter →

arxiv 2507.22829 v1 pith:P2EAKYG4 submitted 2025-07-30 cs.CL

Weijia Zhang , Songgaojun Deng , Evangelos Kanoulas This is my paper
classification cs.CL
keywords query-focusedtablesummarizationstructuredplanningTaSoFSPaGeSQLexecutionmulti-tablereasoninglargelanguagemodelsplan-then-execute
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

Query-focused table summarization is usually driven by step-by-step natural language plans, but those plans are ambiguous and hard to turn into executable SQL. This paper argues that the remedy is to formalize the plan itself, and it introduces TaSoF, a structured plan format in which each step is a typed class with ID, OPERATION, SOURCE, CONDITION, and OUTPUT fields drawn from a fixed menu of nine table operations. In the accompanying framework SPaGe, these plans are compiled to SQL and executed as a directed acyclic graph, so independent steps can run in parallel. Across three benchmarks, SPaGe outperforms prior prompt-based and program-augmented baselines; on the multi-table QFMTS benchmark, TaSoF beats the natural-language plan formats QPL and QDMR in both summary quality and execution success rate.

What carries the argument

The central object is TaSoF (Table State and operation Flow), a class-based plan format inspired by formalisms in multi-agent systems. A plan is a list of Step instances, each carrying an integer ID, an OPERATION from a fixed menu of nine table operations, a SOURCE list naming input tables or earlier steps, a CONDITION string for filters or join keys, and an OUTPUT list of result columns. The machinery around it is SPaGe's three-phase loop: an LLM planner emits TaSoF plans, an executor converts each step into SQL and runs it through an external code interpreter while respecting a DAG of SOURCE dependencies, and a summary generator writes the final answer from the last execution table. The key-value schema is what makes the plan unambiguous enough to compile straight to SQL and parallelizable enough to execute independent branches in the same cycle.

What would settle it

Run the same queries under QPL, QDMR, and TaSoF with identical planner and executor prompts, demonstrations, and random seeds, and check whether TaSoF's execution success rate stays near 98.2% versus 95.1% for QPL; if the gap collapses or reverses, the structured format is not the cause.

Watch

Extended reading notes

Core claim

The paper's central claim is that free-form natural language plans are the main source of unreliability in LLM-based query-focused table summarization, and that a typed, machine-readable plan format fixes it. TaSoF represents each reasoning step as {ID, OPERATION, SOURCE, CONDITION, OUTPUT}, with OPERATION restricted to Scan, Aggregate, Filter, Sort, TopSort, Join, Except, Intersect, and Union, and OUTPUT restricted to columns that actually exist in the source tables. By making dependencies explicit through SOURCE and conditions explicit through CONDITION, the format converts cleanly to SQL, lets the executor build a DAG of step dependencies, and removes ambiguities such as computing "duration" when no duration column exists. The reported evidence is that SPaGe achieves 45.7 BLEU, 68.3 ROUGE-L, and 73.4 METEOR on QFMTS, versus 43.4, 66.2, and 71.5 for the best natural-language-plan baseline QPL, with a 98.2% step execution success rate.

Load-bearing premise

The load-bearing premise is that the comparison to the natural-language plan formats is fair, so the planner, executor, prompts, demonstrations, and model are identical except for the plan format itself.

Editorial extensions

If this is right

  • A TaSoF-style format can replace natural language plans in plan-then-execute table summarization and improve both summary metrics and SQL execution success rate.
  • Independent plan steps can run in parallel, cutting the average number of execution cycles by roughly 28% on the multi-table QFMTS benchmark.
  • The structured format generalizes across single-table benchmarks (FeTaQA, QTSumm) and a multi-table benchmark (QFMTS), showing it is not tied to one table layout.
  • Execution reliability rises to 98.2% on QFMTS, so fewer queries abort with SQL runtime errors than with QPL or QDMR plans.
  • Using only the table schema plus a few top rows in planner inputs retains performance while reducing token usage, lowering the cost of planning on large tables.

Reading between the lines

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

  • Editorial inference: the same Step schema could transfer to text-to-SQL and table fact verification, where the failure mode is also converting natural-language sub-questions into executable operations.
  • Editorial inference: restricting outputs to existing column names is a likely mechanism behind the execution-success-rate gain, so an ablation that allows arbitrary output expressions in TaSoF would test whether schema discipline, rather than the key-value format, drives the result.
  • Editorial inference: because graph execution makes step dependencies explicit, the planner's error surface shifts from phrasing to operation selection, so future work could add plan validation or repair before SQL generation.
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

3 major / 6 minor

Summary. The paper proposes TaSoF, a structured plan representation for query-focused table summarization in which each reasoning step is a class with ID, OPERATION, SOURCE, CONDITION, and OUTPUT fields, and SPaGe, a three-phase framework that generates TaSoF plans, executes them via SQL through a dependency graph, and produces the final summary. The method is evaluated on FeTaQA, QTSumm, and QFMTS against several prompt-based and program-augmented baselines, with an additional comparison of TaSoF against two named plan formats (QDMR and QPL) and an efficiency analysis of graph-based execution. The paper claims that structured plans are less ambiguous than natural-language plans, lead to higher execution success, and enable parallel execution, and that SPaGe consistently outperforms prior models in both single- and multi-table settings.

Significance. If the central claim holds, the paper makes a useful contribution: it provides a concrete, machine-readable plan schema for table reasoning and shows that such a schema can be translated into SQL more reliably than free-form natural-language plans, while also enabling DAG-based parallel execution. The evaluation uses three public benchmarks, including a multi-table benchmark, and the paper reports held-out test-set results, compares against several established baselines, and includes an explicit plan-format comparison and an efficiency measurement. The load-bearing advantage of the paper, however, is the causal attribution of the gains to the TaSoF representation itself; the current manuscript does not supply the prompts, demonstrations, or executor details needed to audit that attribution, and one of the headline claims is contradicted by the paper's own Table 3. The idea is promising and the empirical framework is standard, but the evidence as presented is not yet sufficient to support the strong claims made.

major comments (3)
  1. [§1/§6.1, Table 3] The abstract and §6.1 claim that SPaGe 'consistently outperforms prior models' in both single- and multi-table settings, but Table 3 shows that on QTSumm the prompt-based baseline Reason-then-Summ beats SPaGe on BLEU (21.8 vs 20.9), ROUGE-L (42.3 vs 41.3), and METEOR (51.5 vs 47.7). The claim therefore needs to be qualified, for example as outperforming baselines on FeTaQA and QFMTS while being competitive on QTSumm, and the nested-header explanation in §6.1 should be tied to this result rather than to an unconditional claim.
  2. [§6.2, Table 4] The comparison of TaSoF with QPL and QDMR is the only direct evidence for the central mechanistic claim that the structured format, rather than prompt tuning or dataset artifacts, drives the gains. The statement that the planner was 'adapt[ed]... while keeping all other components unchanged' does not establish format-neutrality, because the executor is prompted to translate each step into SQL with in-context demonstrations; if those demonstrations are written in TaSoF notation, the executor is implicitly tuned for TaSoF and must perform an extra translation step for QDMR or QPL. The paper provides no prompts, no sample adapted plans, and no description of how the executor consumed each plan format, so the reported 3.1-point ESR gap conflates representation quality with prompt-and-demonstration fit. The authors should include or release this material and show that the planner prompts, demonstrations, and executor prompts are symmetric across formats.
  3. [§6.2, Table 4] The claim that TaSoF achieves a 'significantly higher' execution success rate of 98.2% versus 95.1% is not supported by any significance test, confidence interval, or repeated-run variance, despite ESR being measured on only 608 examples. The word 'significantly' should be removed or a paired significance test (e.g., bootstrap or McNemar) should be reported. The same applies to the main results in Table 3, where the reported margins are often within 1–3 BLEU or ROUGE points and no variance or significance information is given.
minor comments (6)
  1. [Abstract and §4.3] The abstract states that execution is modeled via a 'directed cyclic graph,' while §4.3 and Figure 3 describe a directed acyclic graph; the abstract should be corrected to 'directed acyclic graph.'
  2. [§4.2, Plan Generation] The paper says that including only the top-k rows retains performance, but it does not report the value of k or the accompanying ablation; please specify k for each dataset and report the sensitivity, since this is a tunable hyperparameter.
  3. [§5.5] The implementation details mention '3-shot demonstrations' for the planner, executor, and summary generator, but the paper does not describe how demonstrations were selected or what they contain; including one full example per component would be important for reproducibility.
  4. [§6.2, Table 4] The plan-format comparison is reported only on QFMTS; given that QTSumm and FeTaQA have different table structures, reporting the same comparison on at least one single-table dataset would strengthen the generality of the conclusion.
  5. [§4.2, Table 1] The paper asserts that the nine table operations 'cover the most common scenarios,' but it does not report the frequency of each operation in the generated plans; an operation-frequency analysis would support the coverage claim and help readers judge whether the operation set limits plan expressiveness.
  6. [Table 5] In the second qualitative example, the TaSoF notation for Step2 contains an unmatched bracket and the step is missing the closing brace; this should be fixed for clarity.

Circularity Check

0 steps flagged · score 2.0 of 10

No circular derivation: results come from fixed held-out test sets; no fitted parameter or prior result is re-issued as a prediction. The one self-citation (authors' QFMTS benchmark) is public and externally checkable, not load-bearing. The §6.2 format comparison is empirical, not a reduction by construction, though unauditable without prompts/code.

full rationale

The derivation chain is: define the TaSoF schema (Fig. 2, §4.2) → LLM planner emits TaSoF → executor converts each step to SQL → external interpreter executes → summary generator writes the final text → metrics (BLEU/ROUGE-L/METEOR/ESR) on fixed test sets. Nothing in this chain re-derives the outputs from the inputs by construction. ESR ('proportion of plan steps that can be successfully executed', §6.2) and the summary metrics are measured on held-out data, and the planner's top-k row truncation (§4.2) is an engineering choice, not a fitted parameter renamed as a prediction. The §6.3 execution-cycle reduction is explicitly definitional ('the number of execution cycles corresponds to the length of the longest path in the DAG') and is presented as a transparent algorithmic property of the plan, which is legitimate rather than circular. The only self-citation is the QFMTS benchmark (Zhang et al. 2024a), co-authored by two of the present authors; it is the sole multi-table dataset, so the headline multi-table claim rests on it, but the benchmark is a fixed public artifact with annotated query-summary pairs, SPaGe's outputs on it are externally checkable, and the same prior paper supplies the Reason-then-Summ baseline that SPaGe beats. Self-citation is present but not load-bearing in any definitional sense. Two passages need flagging, both evidence-quality rather than circular. First, §6.2: 'we adapt our planner to generate each plan format while keeping all other components unchanged' asserts, but does not document, fairness; the planner prompts, the 3-shot demonstrations (§5.5), and the executor demonstrations are never shown, so the reported 98.2% vs 95.1% ESR gap could partly reflect prompt-and-demonstration fit rather than the TaSoF format itself. That is an unverified condition of the causal claim, not a definitional equivalence, and no equation or prompt is available to exhibit a reduction. Second, the abstract's claim that SPaGe 'consistently outperforms prior models in both single- and multi-table settings' is contradicted by the paper's own Table 3, where Reason-then-Summ beats SPaGe on QTSumm on all three metrics (21.8/42.3/51.5 vs 20.9/41.3/47.7); the body (§6.1) acknowledges this, and 'significantly higher' ESR in §6.2 is stated without a significance test.

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

The framework introduces one representational artifact (TaSoF) but no free-floating physical entities. The central dependencies are the operation set and the linearization scheme, both of which are design choices without independent justification. The main free parameter is the undisclosed top-k value used in table linearization.

free parameters (2)
  • k (top-k rows for table linearization) = Not reported
    The planner uses only the top-k rows of each table, claiming performance is retained while token usage drops, but the value of k and the supporting ablation are not given.
  • Number of in-context demonstrations = 3
    Three-shot demonstrations are used for planner and executor prompts; no ablation shows sensitivity to this choice.
assumptions (4)
  • ad hoc to paper The nine table operations in Table 1 are sufficient to cover all reasoning required by the benchmarks.
    The operation set is presented without justification or analysis of coverage.
  • domain assumption Linearized table schemas with top-k rows preserve enough information for planning.
    The paper claims this is shown by experiments but does not report them.
  • domain assumption The LLM planner, executor, and summarizer produce valid structured plans, SQL, and summaries when prompted.
    The whole framework depends on gpt-4o-mini following the schema and code generation instructions.
  • ad hoc to paper The adaptation of the planner to QPL and QDMR is fair and the executor is format-neutral.
    The key ablation in Section 6.2 assumes that observed differences come from the plan format, not from prompt or executor tuning.
invented entities (1)
  • TaSoF step schema (ID, OPERATION, SOURCE, CONDITION, OUTPUT)
    purpose: Represents a table operation as a structured record to make LLM-to-SQL conversion more reliable.
    The schema is introduced by this paper; its only support is the experimental comparison, which itself relies on the unverified fairness assumption.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Beyond Natural Language Plans: Structure-Aware Planning for Query-Focused Table Summarization." pith.science (2026). https://pith.science/paper/P2EAKYG4

@misc{pith2026250722829,
  author       = {Pith},
  title        = {Pith review of: Beyond Natural Language Plans: Structure-Aware Planning for Query-Focused Table Summarization},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/P2EAKYG4}},
  note         = {Machine review of arXiv:2507.22829}
}
read the original abstract

Query-focused table summarization requires complex reasoning, often approached through step-by-step natural language (NL) plans. However, NL plans are inherently ambiguous and lack structure, limiting their conversion into executable programs like SQL and hindering scalability, especially for multi-table tasks. To address this, we propose a paradigm shift to structured representations. We introduce a new structured plan, TaSoF, inspired by formalism in traditional multi-agent systems, and a framework, SPaGe, that formalizes the reasoning process in three phases: 1) Structured Planning to generate TaSoF from a query, 2) Graph-based Execution to convert plan steps into SQL and model dependencies via a directed cyclic graph for parallel execution, and 3) Summary Generation to produce query-focused summaries. Our method explicitly captures complex dependencies and improves reliability. Experiments on three public benchmarks show that SPaGe consistently outperforms prior models in both single- and multi-table settings, demonstrating the advantages of structured representations for robust and scalable summarization.

Figures

Figures reproduced from arXiv: 2507.22829 by the authors.

Figure 1
Figure 1. An example comparing a natural language plan with our proposed structured plan, TaSoF. The natural language plan includes vague terms such as pet ownership, which can be hard for LLMs to interpret. In contrast, TaSoF follows standard class definitions and specifies table-specific operations, making it easier for LLMs to understand. training data and lacked interpretability (Nguyen et al., 2025). With the rapid advan… view at source ↗
Figure 2
Figure 2. Class definition of our structured plan TaSoF [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. The overview of our framework SPaGe. First, the planner generates a plan during structured planning. [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Comparison of the average number of ex￾ecution cycles between previous sequential execution (SEQ) and our graph-based execution (Ours). Binder achieve higher scores on QFMTS. This dif￾ference mainly comes from the structure of the source tables. Tables in QTSumm, colle…

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

32 extracted references · 25 canonical work pages

  1. [1]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block STRING...

  2. [2]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

  3. [3]

    Satanjeev Banerjee and Alon Lavie. 2005. METEOR : An automatic metric for MT evaluation with improved correlation with human judgments. In Proceedings of the ACL Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization , pages 65--72

    work page 2005

  4. [4]

    Tom B Brown, Benjamin Mann, and et al. 2020. Language Models are Few-Shot Learners . In Advances in Neural Information Processing Systems

    work page 2020

  5. [5]

    Wenhu Chen, Hongmin Wang, and et al. 2020. TabFact : A large-scale dataset for table-based fact verification. In ICLR

    work page 2020

  6. [6]

    Smith, and Tao Yu

    Zhoujun Cheng, Tianbao Xie, Peng Shi, Chengzu Li, Rahul Nadkarni, Yushi Hu, Caiming Xiong, Dragomir Radev, Mari Ostendorf, Luke Zettlemoyer, Noah A. Smith, and Tao Yu. 2023. Binding language models in symbolic languages. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023 . OpenReview.net

    work page 2023

  7. [7]

    Wooldridge

    Mark d'Inverno , Michael Fisher, Alessio Lomuscio, Michael Luck, Maarten de Rijke , Mark Ryan, and Michael J. Wooldridge. 1997. https://doi.org/10.1017/S0269888997003068 Formalisms for multi-agent systems . Knowledge Engineering Review, 12(3):315--321

    work page doi:10.1017/s0269888997003068 1997

  8. [8]

    Ben Eyal, Moran Mahabi, Ophir Haroche, Amir Bachar, and Michael Elhadad. 2023. https://doi.org/10.18653/v1/2023.findings-emnlp.910 Semantic decomposition of question and SQL for text-to- SQL parsing . In Findings of the Association for Computational Linguistics: EMNLP 2023 , pages 13629--13645

    work page doi:10.18653/v1/2023.findings-emnlp.910 2023

Show all 32 references
  1. [9]

    Pablo Gruer, Vincent Hilaire, Abder Koukam, and Krzysztof Cetnarowicz. 2002. https://doi.org/10.1016/S0957-4174(02)00070-2 A formal framework for multi-agent systems analysis and design . Expert Systems With Applications, 23(4):349--355

    2002 doi

  2. [10]

    Vincent Hilaire, Abder Koukam, Pablo Gruer, and Jean-Pierre M \"u ller. 2000. https://doi.org/10.1007/3-540-44539-0\_9 Formal specification and prototyping of multi-agent systems . In Engineering Societies in the Agent World, First International Workshop, ESAW 2000, Berlin, Ge...

    2000 doi

  3. [11]

    Zhengbao Jiang, Yi Mao, Pengcheng He, Graham Neubig, and Weizhu Chen. 2022. OmniTab : Pretraining with natural and synthetic data for few-shot table-based question answering. In Proceedings of the 2022 Conference of the North American Chapter of the Association for Computation...

    2022

  4. [12]

    Qianlong Li, Chen Huang, Shuai Li, Yuanxin Xiang, Deng Xiong, and Wenqiang Lei. 2024. https://doi.org/10.48550/arXiv.2412.01230 GraphOTTER : Evolving LLM-based Graph Reasoning for Complex Table Question Answering . Preprint, arXiv:2412.01230

    2024 doi arXiv

  5. [13]

    Chin-Yew Lin and Eduard Hovy. 2003. Automatic evaluation of summaries using N-gram co-occurrence statistics. In NAACL, pages 150--157

    2003

  6. [14]

    Ao Liu, Haoyu Dong, Naoaki Okazaki, Shi Han, and Dongmei Zhang. 2022 a . PLOG : Table-to-logic pretraining for logical table-to-text generation. In EMNLP

    2022

  7. [15]

    Qian Liu, Bei Chen, Jiaqi Guo, Morteza Ziyadi, Zeqi Lin, Weizhu Chen, and Jian-Guang Lou. 2022 b . TAPEX : Table pre-training via learning a neural SQL executor. In ICLR

    2022

  8. [16]

    Qingyang Mao, Qi Liu, Zhi Li, Mingyue Cheng, Zheng Zhang, and Rui Li. 2024. https://doi.org/10.48550/arXiv.2412.04272 PoTable : Programming Standardly on Table-based Reasoning Like a Human Analyst . Preprint, arXiv:2412.04272

    2024 doi arXiv

  9. [17]

    Linyong Nan, Chiachun Hsieh, and et al. 2022. FeTaQA : Free-form table question answering. Transactions of the Association for Computational Linguistics, 10:35--49

    2022

  10. [18]

    Giang Nguyen, Ivan Brugere, Shubham Sharma, Sanjay Kariyappa, Anh Totti Nguyen, and Freddy Lecue. 2025. https://doi.org/10.48550/arXiv.2412.12386 Interpretable LLM-based Table Question Answering . Preprint, arXiv:2412.12386

    2025 doi arXiv

  11. [19]

    Vaishali Pal, Andrew Yates, Evangelos Kanoulas, and Maarten de Rijke . 2023. MultiTabQA : Generating tabular answers for multi-table question answering. In ACL, pages 6322--6334

    2023

  12. [20]

    Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. 2002. Bleu: A method for automatic evaluation of machine translation. In ACL, pages 311--318

    2002

  13. [21]

    Panupong Pasupat and Percy Liang. 2015. Compositional semantic parsing on semi-structured tables. In ACL, pages 1470--1480

    2015

  14. [22]

    Timo Schick, Jane Dwivedi-Yu , Roberto Dess \` , Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. 2023. Toolformer: Language models can teach themselves to use tools. In Advances in Neural Information Processing Systems 36: An...

    2023

  15. [23]

    Lei Wang, Wanyu Xu, Yihuai Lan, Zhiqiang Hu, Yunshi Lan, Roy Ka-Wei Lee, and Ee-Peng Lim. 2023. https://doi.org/10.18653/v1/2023.acl-long.147 Plan-and-solve prompting: Improving zero-shot chain-of-thought reasoning by large language models . In Proceedings of the 61st Annual M...

    2023 doi

  16. [24]

    Zilong Wang, Hao Zhang, Chun-Liang Li, Julian Martin Eisenschlos, Vincent Perot, Zifeng Wang, Lesly Miculicich, Yasuhisa Fujii, Jingbo Shang, Chen-Yu Lee, and Tomas Pfister. 2024. Chain-of-table: Evolving tables in the reasoning chain for table understanding. In The Twelfth In...

    2024

  17. [25]

    Chi, Quoc V

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H. Chi, Quoc V. Le, and Denny Zhou. 2022. Chain-of-thought prompting elicits reasoning in large language models. In NeurIPS

    2022

  18. [26]

    Tomer Wolfson, Daniel Deutch, and Jonathan Berant. 2022. https://doi.org/10.18653/v1/2022.findings-naacl.193 Weakly supervised text-to- SQL parsing through question decomposition . In Findings of the Association for Computational Linguistics: NAACL 2022 , pages 2528--2542

    2022 doi

  19. [27]

    Yunhu Ye, Binyuan Hui, Min Yang, Binhua Li, Fei Huang, and Yongbin Li. 2023. Large language models are versatile decomposers: Decomposing evidence and questions for table-based reasoning. In Proceedings of the 46th International ACM SIGIR Conference on Research and Development...

    2023

  20. [28]

    Weijia Zhang, Vaishali Pal, Jia-Hong Huang, Evangelos Kanoulas, and Maarten de Rijke. 2024 a . QFMTS : Generating query-focused summaries over multi-table inputs. In Proceedings of the 27th European Conference on Artificial Intelligence (ECAI), pages 3875--3882

    2024

  21. [29]

    Yunjia Zhang, Jordan Henkel, Avrilia Floratou, Joyce Cahoon, Shaleen Deep, and Jignesh M. Patel. 2024 b . https://doi.org/10.14778/3659437.3659452 ReAcTable : Enhancing ReAct for table question answering . Proc. VLDB Endow., 17(8):1981--1994

    2024

  22. [30]

    Zhehao Zhang, Yan Gao, and Jian-Guang Lou. 2024 c . E ^5 : Zero-shot hierarchical table analysis using augmented LLMs via explain, extract, execute, exhibit and extrapolate. In Proceedings of the 2024 Conference of the North American Chapter of the Association for Computationa...

    2024

  23. [31]

    Yilun Zhao, Lyuhao Chen, Arman Cohan, and Chen Zhao. 2024. TaPERA : Enhancing faithfulness and interpretability in long-form table QA by content planning and execution-based reasoning. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (...

    2024

  24. [32]

    Yilun Zhao, Zhenting Qi, and et al. 2023. QTSumm : Query-focused summarization over tabular data. In EMNLP, pages 1157--1172

    2023

Pith tools

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