Verify-in-the-Graph: Entity Disambiguation Enhancement for Complex Claim Verification with Interactive Graph Representation

Hoang Pham; Khac-Hoai Nam Bui; Thanh-Do Nguyen

REVIEW 5 major objections 5 minor 18 references

Verify-in-the-Graph: Entity Disambiguation Enhancement for Complex Claim Verification with Interactive Graph Representation

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

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

Pith's one-line read VeGraph turns a complex claim into graph triplets, resolves hidden entities by iterative knowledge-base lookup, and verifies the rest; this matches or beats LLM baselines on HoVer and FEVEROUS.

desk verdict Sensible incremental LLM-agent fact-checking framework with a clear mechanism; the evaluation needs a statistical pass before the performance numbers can be trusted. read the letter →

arxiv 2505.22993 v1 pith:63WGX7FF submitted 2025-05-29 cs.CL cs.AIcs.DBcs.IR

Hoang Pham , Thanh-Do Nguyen , Khac-Hoai Nam Bui This is my paper

classification cs.CLcs.AIcs.DBcs.IR

keywords claimverificationentitydisambiguationgraphrepresentationLLMagentsmulti-hopreasoningfact-checkingknowledgebaseinteractioniterative

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

VeGraph is a claim-verification pipeline built around the idea that the hardest part of verifying a complex claim is not reading the claim but resolving the entities it leaves hidden or ambiguous. The paper proposes to decompose a claim into graph triplets, have an LLM agent iteratively query a knowledge base to pin down the ambiguous entities, and only then verify the remaining sub-claims. It reports that this pipeline, with at most five disambiguation iterations, reaches Macro-F1 of 69.70, 66.13, and 58.59 on HoVer 2-, 3-, and 4-hop claims, and 73.89 and 82.60 on FEVEROUS Disambiguation and Numerical partitions, matching or beating reproduced LLM baselines. The importance, if true, is that explainable fact-checking can be improved by making entity resolution an explicit, interactive, and logged stage rather than a single implicit lookup.

What carries the argument

The load-bearing object is the graph state: a set of triplets in which ambiguous entities are placeholder nodes, updated in place as each entity gets resolved. Around that graph, the mechanism is an iterative question-refinement loop—group triplets by shared placeholder, ask the LLM for a question with rationale and used triplet ids, retrieve top-k documents through a sparse BM25 plus dense bi-encoder and reranker stack, and ask the Entity Identification function to name the entity; failures feed the rationale and question back into the next iteration, while successes rewrite the graph and mark the contributing triplets verified. The Sub-claim Verification function then checks the unverified triplets. The graph is what lets each successful resolution propagate to other triplets that mention the same entity.

What would settle it

A decisive test is to run VeGraph on HoVer holding the retriever fixed and compare the full iterative loop against a variant that asks only one question per ambiguous entity; if the 4-hop Macro-F1 does not fall below 58.59 in the single-question condition, the iterative interaction is not the source of the reported gain.

Watch

Extended reading notes

Core claim

The paper's claim is that representing a claim as a graph of (entity, relation, entity) triplets—with unresolved entities left as placeholders—and then resolving those placeholders through repeated knowledge-base interactions yields more accurate verdicts on complex claims than existing LLM decomposition pipelines. The pipeline has three stages: graph construction via few-shot prompting; entity disambiguation, where triplets sharing a placeholder are grouped, the LLM generates a rationale, question, and triplet ids, the Entity Identification function returns an entity or null, and failed questions are fed back for refinement while successful resolutions update the graph; and sub-claim verification, where the remaining triplets are turned into natural-language sub-claims and checked against retrieved documents. The verdict is Supported only if every sub-claim is true, and Refuted otherwise. On HoVer, VeGraph reports gains that grow with hop count, culminating in 58.59 Macro-F1 on 4-hop claims, and on FEVEROUS it reports 82.60 on the Numerical partition; the authors attribute these gains to iterative disambiguation interacting with the graph state, and their ablation shows both the graph representation and the number of allowed iterations matter.

Load-bearing premise

The framework assumes that the language model builds faithful triplets and that its disambiguation questions make the retriever find the right entity; the paper's own error analysis attributes 37-53% of failures to entity disambiguation and 32-38% to sub-claim verification, so any slip at either stage flows directly into the final verdict.

Editorial extensions

If this is right

On claims that need several reasoning hops, skipping or limiting the disambiguation loop costs the most: VeGraph's 4-hop HoVer Macro-F1 rises from 43.57 with zero steps to 58.59 with five.
A claim is only judged Supported if every remaining triplet is verified true; any unresolved ambiguous entity defaults the claim to Refuted, so the system errs toward rejection when evidence is missing.
The same unified pipeline, with no task-specific prompts, reaches 73.89 on FEVEROUS Disambiguation and 82.60 on Numerical, both above the reproduced baselines in the same setup.
The cost of this accuracy is visible: VeGraph uses more LLM calls and knowledge-base interactions than ProgramFC or FOLK, with total inference time about 40-50% higher than ProgramFC on HoVer.

Reading between the lines

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

Because the paper's Table 3 puts entity disambiguation ahead of sub-claim verification as the biggest error source, improving retrieval recall rather than LLM reasoning may be the highest-leverage next step for this pipeline.
The iterative disambiguation loop is a general pattern: the same triplet-grouping and question-refinement machinery could be ported to other knowledge-base-dependent tasks such as open-domain question answering or grounded dialogue, where hidden entities also block verification.
A cheap testable extension would be to measure whether VeGraph's final verdict accuracy tracks its per-claim entity-resolution success rate (Table 5 reports 67-72% resolution) more closely than it tracks graph-construction quality.

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.

Desk Editor's Note

read the letter

VeGraph is an incremental but sensible extension of the LLM-agent claim-verification line: it decomposes claims into graph triplets, uses an agent to iteratively disambiguate ambiguous entities against a Wikipedia knowledge base, and then verifies the remaining triplets. The pieces are known, but the specific interactive graph-state loop is new, and the paper makes a plausible case that it helps on hard multi-hop claims.

The best parts are the methodology and transparency. The pipeline is clearly specified, all prompts are in the appendix, and the authors reproduce baselines under a unified backbone and retrieval setup instead of just quoting prior numbers. The ablation on HoVer shows monotonic improvement as the iteration limit k goes from 0 to 5, which is real evidence that the disambiguation loop is doing useful work. The cost analysis and the human error breakdown (Table 3) are also a plus; they show the authors know where the system fails.

The soft spot is purely statistical, and it is exactly where the reader and the stress-test note point. HoVer numbers are computed on 200 samples per partition, so the 5.38-point gap over the ensembled ProgramFC baseline on 4-hop could move with a handful of verdict flips, and no error bars or significance tests are reported. The FEVEROUS evaluation is on an unspecified filtered subset: the paper says only sentence-based claims are kept, but not how many claims survive per partition or what the label mix looks like, so the 82.60 Numerical score is not comparable to anything public. Most baselines are single runs, and k=5 plus the few-shot graph examples were chosen on the same validation sets that produce the reported numbers. None of this breaks the mechanism; it just means the performance advantage is a point estimate, not an established result.

The paper is honest about its limitations, and the method is worth a serious referee. A revision that adds more samples or bootstrap intervals, reports the exact FEVEROUS subset sizes, and gives a seed-variance estimate would make this a solid contribution. I would take it for peer review and tell the authors the experiments need that statistical pass before publication.

Referee Report

5 major / 5 minor

Summary. VeGraph is a three-stage LLM-agent framework for complex claim verification. In the Graph Representation stage, an LLM decomposes a claim into a set of triplets (head, relation, tail), marking ambiguous entities as placeholders. In the Entity Disambiguation stage, the agent groups triplets by shared ambiguous entities and iteratively generates retrieval questions, consults a sparse-and-dense retriever over Wikipedia, and updates the graph until all entities are resolved or a maximum iteration k is reached; unresolved entities cause the claim to be classified as REFUTES. In the Verification stage, remaining triplets are converted to sub-claims and verified against retrieved documents, and the claim is SUPPORTED only if all sub-claims are true. The paper evaluates VeGraph on validation sets of HoVer and FEVEROUS using Meta-Llama-3-70B-Instruct and reports Macro-F1 scores, claiming competitive performance and notable gains on HoVer 4-hop and FEVEROUS Numerical partitions.

Significance. If the reported results are robust, VeGraph contributes a novel combination of graph-based claim decomposition, iterative disambiguation with explicit LLM-agent feedback loops, and a logging module for interpretability. The method produces explanation traces (examples in Appendix C), and the authors release code and prompts, which materially supports reproducibility. The cost analysis (Table 4) and the entity-resolution success rates (Table 5) give a useful picture of the framework's overhead. However, the significance is currently bounded by the thin evaluation: small samples, unspecified filtered subsets, and absence of variance measures prevent the reported gains from being established beyond sampling noise.

major comments (5)

[§4.1, Table 1] The HoVer results are computed on only 200 sampled claims per partition with balanced labels. With N=200, the 5.38-point Macro-F1 gap on 4-hop claims (58.59 vs 53.21 for ProgramFC 5-run ensemble) corresponds to roughly 5–10 additional correct verdicts, and no confidence intervals, bootstrap estimates, or significance tests are reported anywhere. Please report variance over multiple runs or seeds and provide a statistical justification for the sample size, since the central claim of competitive performance rests on these numbers.
[§4.1, FEVEROUS subset] The FEVEROUS evaluation is performed on an unspecified filtered subset: the paper states only that claims requiring sentence-based evidence are kept and table-cell claims are discarded, without reporting the number of claims per partition (Multi-hop, Disambiguation, Numerical), the exact filter rule, or the label distribution. If the filter disproportionately removes difficult or table-dependent claims, the reported 82.60 Numerical score is not comparable to baselines evaluated on a different sample. Please specify the filtering procedure and report per-partition counts and statistics.
[§4.3] The maximum disambiguation iterations k=5 and the few-shot graph-construction examples were selected on the development/validation data, and the final results are reported on that same validation set. This introduces selection bias; please clarify how the validation set is used (e.g., whether the final numbers also come from the same set used for hyperparameter choice) and, if so, discuss the overfitting risk or hold out a separate test subset.
[§4.5, Table 2] The ablation in Table 2 shows a monotonic improvement with k, but the improvement from 2 to 5 steps on the 2-hop partition is exactly zero (69.70 in both cases). Since no variance estimates are given, it is unclear whether the 3-hop and 4-hop improvements (63.82 to 66.13 and 57.33 to 58.59) are distinguishable from noise. Please add variability measures or at least state the number of runs behind each ablation table.
[§4.6, Table 3] The paper's own error analysis shows that entity disambiguation failures account for 37–53% of errors across partitions and subclaim verification for 32–38%, meaning the two core contributions of the framework are also its primary points of failure. The claim that enhanced entity disambiguation leads to gains (Section 4.4) is therefore only partially supported; please discuss how these high remaining error rates interact with the claimed advantage over baselines, e.g., by comparing error-type distributions of baselines where possible.

minor comments (5)

[§3.4] A typo appears in the text: 'Ref uted' should be 'Refuted'.
[Figure 5] The 'Wrong Graph' example omits the head entity in the first triplet ('||stars in||Wild About Harry'), which makes the figure confusing; please fix the rendering.
[Appendix D] The prompt titles (e.g., 'Prompt template to find related section content from articles') are copied across all prompts and do not describe the actual functions; please retitle them to reflect their purposes.
[Table 1 caption] The caption says 'Both texts indicate the best score', which is unclear; likely intended as 'Bold text indicates the best score'.
[§4.4] The phrase '5-point gain' in the 4-hop HoVer row is imprecise: the gain over the reproduced ProgramFC single-run is 4.63 points and over the 5-run ensemble 5.38 points; please state the comparison route more explicitly.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular derivation: VeGraph is an empirical pipeline whose reported Macro-F1 numbers are not constructed from fitted parameters or self-citations.

full rationale

This paper proposes an empirical LLM-agent pipeline for claim verification; there is no mathematical derivation chain in which an output is defined in terms of the input it is claimed to predict. The graph triplets, disambiguation questions, and verifications are generated by an LLM from the claim and retrieved documents, and the final verdict is a stated aggregation rule over sub-claim verifications (“if all the graph triplets are verified ... then the claim C is Supported, if one of the triplets cannot be verified then the claim C is Refuted”). This is a decision rule, not a circular reduction. The only mild concern is that the maximum iteration k=5 is set on the validation set and the same validation set is used for the reported numbers (“we limit the number of iterations k in our proposed method, VeGraph, to 5” and “Due to the unavailability of public test sets, we rely on validation sets for evaluation”). This is a hyperparameter-selection and evaluation-methodology weakness, not circularity: the reported Macro-F1 values are not fitted values of k, and no equation in the paper makes the prediction equal to the fitted input. Baselines are cited for their original methods, but the paper reproduces them under a unified setup, and no load-bearing claim rests on a self-citation or on an imported uniqueness theorem. Consequently, the derivation chain is self-contained and no circular step can be exhibited under the required standard.

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

No new ontological entities are introduced; the X_i markers are internal placeholders, not postulates about the world. The free parameters are hyperparameters and prompt choices, and the axioms are domain assumptions about LLM reliability, triplet decomposition, and sampling.

free parameters (4)

maximum disambiguation iterations (k) = 5
Ablation in Section 4.5 shows 2 steps gives 57.33 on HoVer 4-hop versus 58.59 with 5; k is a tunable hyperparameter set by computational budget rather than derived.
top-k retrieved documents = 15
Section 4.3 sets a maximum of 15 retrieved documents for KB interactions; chosen by the authors and not justified by analysis.
maximum context tokens = 6000
Section 4.3 limits LLM input to 6000 tokens; part of the manual setup for the backbone Llama-3-70B.
few-shot examples for graph construction = hand-crafted
Appendix D states the few-shot demonstrations were chosen because they perform effectively in practice, implying selection on development data.

assumptions (4)

domain assumption A claim's veracity equals the conjunction of veracity of all its extracted triplets.
Section 3 states the claim is Supported only if all triplets are verified; if triplet decomposition misses or distorts a semantic component, the verdict can flip.
ad hoc to paper Failure to resolve an ambiguous entity after k iterations is treated as evidence that the claim is REFUTED.
Section 3.3 maps unresolved entities to REFUTES; this conflates 'false' with 'unverifiable by the retriever' and can bias verdicts.
domain assumption The LLM reliably produces parseable structured outputs (triplets, questions, JSON veracity labels).
All pipeline stages depend on the prompt templates in Appendix D; malformed or unfaithful LLM output breaks the pipeline.
domain assumption Sampled 200-claim balanced subsets and sentence-only FEVEROUS claims represent the benchmarks.
Section 4.1 describes sampling for cost; no seed or confidence intervals are given, so generalization to the full validation sets is assumed.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Verify-in-the-Graph: Entity Disambiguation Enhancement for Complex Claim Verification with Interactive Graph Representation." pith.science (2026). https://pith.science/paper/63WGX7FF

@misc{pith2026250522993,
  author       = {Pith},
  title        = {Pith review of: Verify-in-the-Graph: Entity Disambiguation Enhancement for Complex Claim Verification with Interactive Graph Representation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/63WGX7FF}},
  note         = {Machine review of arXiv:2505.22993}
}

read the original abstract

Claim verification is a long-standing and challenging task that demands not only high accuracy but also explainability of the verification process. This task becomes an emerging research issue in the era of large language models (LLMs) since real-world claims are often complex, featuring intricate semantic structures or obfuscated entities. Traditional approaches typically address this by decomposing claims into sub-claims and querying a knowledge base to resolve hidden or ambiguous entities. However, the absence of effective disambiguation strategies for these entities can compromise the entire verification process. To address these challenges, we propose Verify-in-the-Graph (VeGraph), a novel framework leveraging the reasoning and comprehension abilities of LLM agents. VeGraph operates in three phases: (1) Graph Representation - an input claim is decomposed into structured triplets, forming a graph-based representation that integrates both structured and unstructured information; (2) Entity Disambiguation -VeGraph iteratively interacts with the knowledge base to resolve ambiguous entities within the graph for deeper sub-claim verification; and (3) Verification - remaining triplets are verified to complete the fact-checking process. Experiments using Meta-Llama-3-70B (instruct version) show that VeGraph achieves competitive performance compared to baselines on two benchmarks HoVer and FEVEROUS, effectively addressing claim verification challenges. Our source code and data are available for further exploitation.

Figures

Figures reproduced from arXiv: 2505.22993 by the authors.

**Figure 2.** Three key components of VeGraph: (i) Graph Representation, which decomposes the complex input claim into graph triplets; (ii) Entity Disambiguation, ambiguous entities are resolved through iterative interactions with the knowledge base (KB); and (iii) Sub-claim Verification, which evaluates each triplet by delegating the verification process to the sub-claim verification function. The logging module records the whol… view at source ↗

**Figure 3.** Prompt to make LLM construct the Graph Representation et al., 2013; Miwa and Bansal, 2016) in an end-toend fashion. Entities (nodes) are defined as spans of text that represent objects, events, or concepts mentioned in the claim. Unlike traditional Named Entity Recognition (NER) systems, which rely on fixed categories, this approach accommodates a more diverse set of entity types. For relation extraction (edges), … view at source ↗

Figures from the paper (12 more)

**Figure 4.** Figure 4: Illustration of the entity disambiguation process [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]

**Figure 5.** Figure 5: Incorrect Example 1 Error in Verifying the Remaining Triplets ### Input Claim: The institution, where Eddie George earned an MBA from, and Middlebury College are both private schools. ### Graph: ||is a||private school Eddie George||earned an MBA from|| Middlebury Colle…

**Figure 6.** Figure 6: Incorrect Example 2 [PITH_FULL_IMAGE:figures/full_fig_p012_6.png]

**Figure 7.** Figure 7: Incorrect Example 3 Correct Example ### Input Claim: Little Big Girl was a Simpsons episode directed by an American animator and artist. ### Graph: Little Big Girl||was directed by|| ||is an||American animator ||is an||artist Little Big Girl||is a||Simpsons episode ###…

**Figure 8.** Figure 8: Correct Example Output 1 [PITH_FULL_IMAGE:figures/full_fig_p013_8.png]

**Figure 9.** Figure 9: Correct Example Output 2 [PITH_FULL_IMAGE:figures/full_fig_p014_9.png]

**Figure 10.** Figure 10: Prompt template to find related section content from articles. [PITH_FULL_IMAGE:figures/full_fig_p015_10.png]

**Figure 11.** Figure 11: Prompt template to find related section content from articles. [PITH_FULL_IMAGE:figures/full_fig_p015_11.png]

**Figure 12.** Figure 12: Prompt template to find related section content from articles. [PITH_FULL_IMAGE:figures/full_fig_p016_12.png]

**Figure 13.** Figure 13: Prompt template to find related section content from articles. [PITH_FULL_IMAGE:figures/full_fig_p016_13.png]

**Figure 14.** Figure 14: Prompt template to find related section content from articles. [PITH_FULL_IMAGE:figures/full_fig_p017_14.png]

**Figure 15.** Figure 15: Prompt template to find related section content from articles. [PITH_FULL_IMAGE:figures/full_fig_p017_15.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

18 extracted references · 17 canonical work pages

[2]

- Return false if the documents provide information that contradicts the claim

To verify the claim: - Return true if the claim is supported by the documents. - Return false if the documents provide information that contradicts the claim

work page
[3]

rationale

Return in the following format: { "rationale": "A short rationale with supported or contradicted evidence to guide the verifying process.", "veracity": "true or false" }

work page
[4]

rationale

If the claim cannot be answered due to insufficient information, return: {"rationale": null, "veracity": null} ### Documents: {{context}} ### Claim: {{claim}} Figure 10: Prompt template to find related section content from articles. QA_WITH_DOCS ### Task: Based only on the information provided in the given documents, answer the question. ### Guidelines:

work page
[11]

Do NOT rely on outside information or generate knowledge yourself

Use only the content from the provided documents to verify the claim. Do NOT rely on outside information or generate knowledge yourself. Avoid making implications

work page
[12]

answer":

Return one specific entity requested in the question in the following format: {"answer": "the one entity you identified"}

work page
[13]

FEW_SHOT_CONSTRUCT_GRAPH ### Task: Construct a graph that captures entities and relationships from a given claim

If the entity is not found in the documents, return {"answer": null} ### Documents: {{context}} ### Question: {{question}} Figure 11: Prompt template to find related section content from articles. FEW_SHOT_CONSTRUCT_GRAPH ### Task: Construct a graph that captures entities and relationships from a given claim. Extract triplets with entities and relations b...

work page
[14]

Only use information from the claim, do NOT include external knowledge

work page
[15]

One of the hosts of the 2012 KBS Drama Awards

Do NOT repeat similar triplets in the graph ### Examples: -- Example 1 -- <input_claim> One of the hosts of the 2022 KBS Drama Awards is a Korean actor. He is well known for his role in a 2016 South Korean television soap opera and starred alongside Han Hyo-joo. Kim Eui-sung also appeared in the series. <guidance_for_graph_construction> The claim mentions...

work page 2022

Show all 18 references

[17]

rationale

You do NOT need to combine all the information of the triplets to form the question. Try one or more aspects corresponding to triplets at a time that is enough to form the question to identify that entity ### Return format: { "rationale": "a short rationale explaining how you ...
[18]

Graph will provided with triplets following the form: triplet_id||entity_1||relation||entity_2
[19]

You MUST generate one new question to resolve the entity in the graph
[20]

rationale

You do NOT need to combine all the information of the triplets to form the question. Try one or more aspects corresponding to triplets at a time that is enough to form the question to identify that entity ### Return format: { "rationale": "a short rationale explaining how you ...
[126]

The Borowitz Report

National Institute of Standards and Technology (NIST). Anastasiia Sedova, Robert Litschko, Diego Frassinelli, Benjamin Roth, and Barbara Plank. 2024. To know or not to know? analyzing self-consistency of large language models under ambiguity. Preprint, arXiv:2407.17125. Haoran...

2024 arXiv
[1994]

In Proceedings of The Third Text REtrieval Conference, TREC 1994, Gaithers- burg, Maryland, USA, November 2-4, 1994, volume 500-225 of NIST Special Publication , pages 109–

Okapi at TREC-3. In Proceedings of The Third Text REtrieval Conference, TREC 1994, Gaithers- burg, Maryland, USA, November 2-4, 1994, volume 500-225 of NIST Special Publication , pages 109–

1994
[2011]

Identifying relations for open information ex- traction. In Proceedings of the 2011 Conference on Empirical Methods in Natural Language Process- ing, EMNLP 2011, 27-31 July 2011, John McIntyre Conference Centre, Edinburgh, UK, A meeting of SIGDAT, a Special Interest Group of t...

2011
[2020]

In Findings of the Association for Computational Linguistics: EMNLP 2020, Online Event, 16-20 November 2020, volume EMNLP 2020 of Findings of ACL, pages 3441–3460

Hover: A dataset for many-hop fact extraction and claim verification. In Findings of the Association for Computational Linguistics: EMNLP 2020, Online Event, 16-20 November 2020, volume EMNLP 2020 of Findings of ACL, pages 3441–3460. Association for Computational Linguistics. ...

2020
[2022]

Proofver: Natural logic theorem proving for fact verification. Trans. Assoc. Comput. Linguistics, 10:1013–1030. Qi Li, Heng Ji, and Liang Huang. 2013. Joint event ex- traction via structured prediction with global features. In Proceedings of the 51st Annual Meeting of the As- ...

2013
[7004]

Stephen E

Association for Computational Linguistics. Stephen E. Robertson, Steve Walker, Susan Jones, Micheline Hancock-Beaulieu, and Mike Gatford

Pith tools

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

[1] [2]

- Return false if the documents provide information that contradicts the claim

To verify the claim: - Return true if the claim is supported by the documents. - Return false if the documents provide information that contradicts the claim

work page

[2] [3]

rationale

Return in the following format: { "rationale": "A short rationale with supported or contradicted evidence to guide the verifying process.", "veracity": "true or false" }

work page

[3] [4]

rationale

If the claim cannot be answered due to insufficient information, return: {"rationale": null, "veracity": null} ### Documents: {{context}} ### Claim: {{claim}} Figure 10: Prompt template to find related section content from articles. QA_WITH_DOCS ### Task: Based only on the information provided in the given documents, answer the question. ### Guidelines:

work page

[4] [11]

Do NOT rely on outside information or generate knowledge yourself

Use only the content from the provided documents to verify the claim. Do NOT rely on outside information or generate knowledge yourself. Avoid making implications

work page

[5] [12]

answer":

Return one specific entity requested in the question in the following format: {"answer": "the one entity you identified"}

work page

[6] [13]

FEW_SHOT_CONSTRUCT_GRAPH ### Task: Construct a graph that captures entities and relationships from a given claim

If the entity is not found in the documents, return {"answer": null} ### Documents: {{context}} ### Question: {{question}} Figure 11: Prompt template to find related section content from articles. FEW_SHOT_CONSTRUCT_GRAPH ### Task: Construct a graph that captures entities and relationships from a given claim. Extract triplets with entities and relations b...

work page

[7] [14]

Only use information from the claim, do NOT include external knowledge

work page

[8] [15]

One of the hosts of the 2012 KBS Drama Awards

Do NOT repeat similar triplets in the graph ### Examples: -- Example 1 -- <input_claim> One of the hosts of the 2022 KBS Drama Awards is a Korean actor. He is well known for his role in a 2016 South Korean television soap opera and starred alongside Han Hyo-joo. Kim Eui-sung also appeared in the series. <guidance_for_graph_construction> The claim mentions...

work page 2022