Optimizing Decomposition for Optimal Claim Verification
Authors: Yining Lu, Noah Ziems, Hy Dang, Meng Jiang
Accepted at: acl25

Optimizing Decomposition for Optimal Claim Verification

Yining Lu    Noah Ziems    Hy Dang    Meng Jiang
University of Notre Dame
South Bend, IN
ylu33@nd.edu

Abstract

Current research on the Decompose-Then-Verify paradigm for evaluating the factuality of long-form text typically treats decomposition and verification in isolation, overlooking their interactions and potential misalignment. We find that existing decomposition policies, typically hand-crafted demonstrations, do not align well with downstream verifiers in terms of atomicity—a novel metric quantifying information density—leading to suboptimal verification results. We formulate finding the optimal decomposition policy for optimal verification as a bilevel optimization problem. To approximate a solution for this strongly NP-hard problem, we propose dynamic decomposition, a reinforcement learning framework that leverages verifier feedback to learn a policy for dynamically decomposing claims to verifier-preferred atomicity. Experimental results show that dynamic decomposition outperforms existing decomposition policies, improving verification confidence by 0.07 and accuracy by 0.12 (on a 0-1 scale) on average across varying verifiers, datasets, and atomcities of input claims.1

1 Introduction

The Decompose-Then-Verify paradigm has been widely used in fact-checking systems, as it reduces the claim complexity and makes the factuality evaluation fine-grained and easy (Min et al., 2023; Chern et al., 2023; Chen et al., 2023; Kamoi et al., 2023; Wei et al., 2024; Song et al., 2024). The paradigm comprises two components: (1) a decomposer, which leverages a large language model (LLM) guided by a decomposition policy—typically hand-crafted prompts—to break claims into subclaims,2 and (2) a verifier, which similarly utilizes LLM paired with a verification policy (e.g., retrieving evidence to assist verification). Figure 1 provides an illustration.

In this work, we first systematically investigate how decomposition policies could affect verification through subclaim atomicity—a metric we introduced for quantifying information density. We find that different verifiers achieve optimal verification confidence at distinct input atomicity. We define atomicity = \( \log_2(\# \text{ atomic information}) \), where one piece of atomic information is an utterance conveying a single nontrivial fact (e.g., “Owen made a comeback in 2017” in Figure 1). Higher atomicity means a subclaim is more coarse-grained and information-rich, which ostensibly implies lower verifier confidence, yet our finding indicates this is not always the case.

The above finding reveals that existing prompt-based decomposition policies do not always generate subclaims with optimal atomicity, resulting in suboptimal verification results. For instance, FActScore (Min et al., 2023) formulates its decomposition policy using eight annotated demonstrations to generate intended atomic subclaims. Our experiments find that verifiers, such as Inst-Llama-7B with the evidence retrieval verification policy shown in Figure 1, do not exhibit optimal performance at the atomicity level (i.e., atomicity = 0) featured by the given decomposition policy. Thus, there is a performance gap between the decomposer and verifier in terms of atomicity, which remains unaddressed. We further discuss the limitations of prior studies in the related work §5.1.

To solve the above problem, we propose dynamic decomposition—a novel framework to learn a decomposition policy tailored to the downstream verifier. Our approach is compatible with any existing fact-checking systems where both the decomposition and verification LLMs are given and frozen. Unlike existing decomposition policies that use a single prompt call to generate subclaims (Min et al.,

1Our code: github.com/yining610/dynamic-decomposition
2Following Jiang et al. (2024), we use claim to denote original sentence to be verified and subclaims the result of decomposition.
Figure 1: Left: overall framework of Decompose-Then-Verify paradigm. We define each decomposer and verifier as a LLM paired with a corresponding policy. Our dynamic decomposition is compatible with existing fact-checking systems and requires training only a decomposition policy with 4.73M parameters. Right: the figure (upper right) shows that the verification confidence of the verifier (i.e., Inst-Llama-7B with a retrieval verification policy) peaks at atomicity 1. An atomicity of -1 denotes the claim is partially trivial and tautological. The example (lower right) shows that the decomposition policy from FActScore (Min et al., 2023) fails to generate subclaims that best evoke the verifier’s performance, leading to suboptimal results. We provide an additional example in Appendix E to show the limitation of existing decomposition policies.

2023; Wei et al., 2024; Hu et al., 2024; Wanner et al., 2024), we formulate dynamic decomposition as a Markov Decision Process (Puterman, 2014) that involves a sequence of decomposition calls. At each step, the policy determines whether a subclaim should be decomposed, with the newly generated subclaims passed to the verifier that returns verification confidence change as a reward.3 Thus, this formulation enables the problem to be tackled using on-policy reinforcement learning (RL).

The learned policy, requiring only 4.73M parameters, significantly improves steerability over decomposition processes by dynamically decomposing claims to the verifier-perferred atomicity level. Extensive experiments show that it outperforms baseline decomposition policies (Min et al., 2023; Kamoi et al., 2023; Wanner et al., 2024), improving both verification confidence (by 0.07) and accuracy (by 0.12) across varying verifiers, datasets, and atomicity levels. In summary, our contributions are twofold:

• Our study exposes the impact of subclaim atomicities on verifiers. We find that each verifier prefers a distinct optimal input atomicity, yet existing decomposition policies hardly achieve the optimum.

• We introduce a RL framework designed to bridge the performance gap between decomposers and verifiers. It learns a decomposition policy to dynamically adjust the atomicity of subclaims tailored to downstream verifiers, thereby optimizing verification results.

2 Methodology

We formulate finding the optimal decomposition policy for optimal verification as a bilevel optimization problem. Specifically, given a decomposition LLM \( \mathcal{D} \), a verification LLM \( \mathcal{V} \), verification policy \( \pi_v \), and a claim dataset \( \{(C_i, Y_i)\} \) with binary factuality labels \( Y_i \), we aim to find an optimal decomposition policy \( \pi_d \) such that decomposed subclaims \( \{c_j\} \) maximize the verification accuracy:

\[
\max_{c \in \{c_j\}, \pi_d} \mathbb{E}_i \left[ \mathbb{I}(Y_i = \bigwedge_c \mathcal{V}(c \mid \pi_v)) \right],
\]

subject to

\[
\pi_d \in \arg\max_{\pi_d} f(\{c_j\}, \pi_d), \quad \{c_j\} \sim \mathcal{D}(C_i \mid \pi_d),
\]

where verifier \( \mathcal{V}(\cdot \mid \pi_v) \) returns the prediction label conditioned on its verification policy. We deter-
mine the claim is true if and only if all its subclaims are true, implemented via a logical AND operator \( \land \). \( f(\cdot) \) represents the lower-level constraint, which observes the decisions \( \{c_j\} \) made at the upper level and optimizes its own policy \( \pi_d \) accordingly (Sinha et al., 2018). Decomposer \( \mathcal{D} \) is the upper-level constraint, ensuring that all subclaims are generated by it under a feasible decomposition policy that is lower-level optimal.

By formulating the problem as a bilevel optimization, we can simultaneously refine the upstream decomposition policy and optimize the downstream verification task, ensuring that the decomposition policy is aligned with the verifier to achieve optimal overall performance. Bilevel optimization is known to be strongly NP-hard (Hansen et al., 1992), and research has shown that it can be alternatively approximated using online stochastic approximation (Qiu et al., 2021). Therefore, we propose our dynamic decomposition as an advantage actor-critic (A2C) style (Mnih et al., 2016) RL solution to approximate Eq.1. It enables the decomposition policy to learn directly from the verifier, dynamically converging toward an optimistic bilevel optimum.

2.1 Overview of Dynamic Decomposition

Unlike most of the prior work that applies its decomposition policy only once, we iteratively generate decomposition calls from the learned decomposition policy. The call is to either request the decomposition LLM to decompose the current subclaim or not. Specifically, given a temporary subclaim list \( \{c_j\} \) and a target subclaim to be decomposed \( c^* \in \{c_j\} \) sampled from it, we perform decomposition \( \mathcal{D}(\cdot|\pi_d) \) in Eq.1 as:

\[
\{c_j\}^* = \begin{cases}
\mathcal{D}(c^*), & \text{if } \pi_d(\{c_j\}) = \text{decompose} \\
\varnothing, & \text{if } \pi_d(\{c_j\}) = \text{not decompose}
\end{cases},
\]

\[
\{c_j\} \leftarrow \kappa(\{c_j\}, \{c_j\}^*).
\]

We repeat the above process until all subclaims in \( \{c_j\} \) have been decided not to decompose further.

Therefore, this can be formulated as a finite MDP defined as \( M = (\mathcal{S}, \mathcal{A}, \kappa, r) \). \( \mathcal{S} \) represents the state space, and \( \mathcal{A} \) is the action space which includes two actions in our case: decompose or not to decompose. \( \kappa : \mathcal{S} \times \mathcal{S}^* \to \mathcal{S} \) is the state transition function that replaces the target subclaim \( c^* \) in the subclaim list \( \{c_j\} \) with its decomposition results \( \{c_j\}^* \). \( r : \mathcal{S} \times \mathcal{S}^* \to \mathcal{A} \) is the immediate reward received from the verifier after state transition.

2.2 Implement Dynamic Decomposition Policy

In this section, we elaborate on how we implement our dynamic decomposition based on the MDP formulation proposed above.

Atomicity state: To find the optimal atomicity that is favored by the verifier, we create an *atomicity state* reflecting the overall atomicity of current subclaims \( \{c_j\} \) at step \( t \). Each atomicity state is a \( d \) dimension vector \( s_t \in \mathbb{R}^d \).

State transition: Similar to the work of Chen et al. (2024b), we use a trainable Gated Recurrent Unit (GRU) (Cho et al., 2014) to model state transition function \( \kappa \) in Eq.3:

\[
s_{t+1} = \mathrm{GRU}\big[s_t, (1+\sigma(\Delta\mathrm{Info}))\mathrm{Enc}(\{c_j\})\big],
\]

where \( \mathrm{Enc}(\cdot) : T \to \mathbb{R}^d \) is a textual encoder that maps the text sequence to a \( d \)-dimensional embedding and \( \sigma : \mathbb{R} \to \mathbb{R} \) is the sigmoid function. We compute \( \Delta\mathrm{Info} \) as the average Conditional Pairwise Mutual Information (CPMI) (Jiang et al., 2024) difference between the target subclaim \( c^* \) and its decomposed results \( \{c_j\}^* \), which basically quantifies how much information is lost from each subclaim after decomposition:

\[
\Delta\mathrm{Info} = \mathbb{E}_{c \in \{c_j\}^*} \Big[ \log \frac{P(c \mid \mathcal{H})}{P(c^* \mid \mathcal{H})} \Big],
\]

where \( P(\cdot \mid \mathcal{H}) \) measures the entailment probability between a claim and a pre-defined set of tautological and bleached claims \( \mathcal{H} \) (e.g., "{topic} is a person", "{topic} exists"). In practice, this conditional probability is estimated as \( \max_{h \in \mathcal{H}} P(\cdot \mid h) \) for better stability (Jiang et al., 2024). As both \( c^* \) and its subclaims \( c \in \{c_j\}^* \) getting syntactically closer to bleached claims through iterative decomposition, \( \Delta\mathrm{Info} \) tend to decrease because of the diminishing marginal information loss (e.g., \( P("Kruger was a religious man"\mid\mathcal{H}) \gg P("Kruger was a deeply ... faith"\mid\mathcal{H}) \gg P("Kruger was a man"\mid\mathcal{H}) \gg P("Kruger was a religious"\mid\mathcal{H}) \); see Figure 6 in Appendix C for experimental justification.).

Therefore, we design \( \Delta\mathrm{Info} \) as a metric to quantify localized atomicity change caused by the current decomposition call, and \( \mathrm{Enc}(\{c_j\}) \) reflects the
overall atomicity of all subclaims in terms of semantics. Multiplying global decomposition embeddings by the local atomicity change in Eq.4 preserves original semantics (Vaswani et al., 2017) while revealing hidden states regarding atomicity of current subclaims.

Action: We define \( \mathcal{A} \) as having only two actions: 1 (decompose) or 0 (not decompose). For each atomicity state, the action is sampled from a policy distribution, \( a_t \sim \pi_d(a_t \mid s_t) \), namely our decomposition policy. \( \pi_d \) is trained to determine when to decompose a claim until achieving the desired atomicity state that maximizes the reward.

Reward: Due to the lack of ground-truth labels for newly generated subclaims, accuracy-based evaluation is not feasible for evaluating verification improvement after decomposition. To address this limitation, we introduce verification confidence, a label-free proxy for accuracy that is computable for all subclaims. It is defined as the absolute probability difference between positive and negative verification labels:

\[
\mathrm{Conf}(c, \mathcal{V}, \pi_v) = |P_{\mathcal{V}}(\text{True} \mid c, \pi_v) - P_{\mathcal{V}}(\text{False} \mid c, \pi_v)|.
\]

Verification confidence measures how much certainty a verifier has in making a verification, which we find to strongly correlate with verification accuracy in Figure 2.

Our reward is the verification confidence change before and after decomposition. This design encourages the policy to perform decomposition when the verifier is more confident in evaluating the factuality of generated subclaims:

\[
r_t = \mathbb{E}_{c \in \{c_j\}^*} \left[ \mathrm{Conf}(c, \mathcal{V}, \pi_v) \right] - \mathrm{Conf}(c^*, \mathcal{V}, \pi_v).
\]

Breadth-First Order Decomposition: In dynamic decomposition, each decomposition call could generate a new list of subclaims at a lower level of atomicity, which are then queued for further decomposition. Therefore, the order of decomposition becomes matter. A depth-first approach, where a single subclaim is continually decomposed until reaching the lowest possible atomicity level, can result in significant variance in atomicity among all subclaims, which in turn leads to high variance in modeling the state (Eq.4). Hence, we employ a breadth-first strategy to prioritize the decomposition of subclaims at higher atomicity. We provide an illustration in Figure 3.

![Verification confidence versus accuracy. The number in each convex hull denotes the claim atomicity. Irrespective of data sources, atomicities, and verifiers, verification confidence exhibits a strong positive correlation with accuracy (0.88 Pearson’s r).](page_1016_98_377_377.png)

Figure 2: Verification confidence versus accuracy. The number in each convex hull denotes the claim atomicity. Irrespective of data sources, atomicities, and verifiers, verification confidence exhibits a strong positive correlation with accuracy (0.88 Pearson’s r).

![Breadth-first order sampling for dynamic decomposition. We perform binary decomposition for each claim. The number in the node represents its sampling priority in the decomposition process. We first sample out subclaims at the same atomicity level, with newly generated subclaims queued in a FIFO (first-in-first-out) order.](page_1016_563_377_377.png)

Figure 3: Breadth-first order sampling for dynamic decomposition. We perform binary decomposition for each claim. The number in the node represents its sampling priority in the decomposition process. We first sample out subclaims at the same atomicity level, with newly generated subclaims queued in a FIFO (first-in-first-out) order.

2.3 Train Dynamic Decomposition Policy

We employ PPO (Schulman et al., 2017) in A2C style to train our dynamic decomposition policy given its effectiveness and stability (Engstrom et al., 2019). We model policy function \( \pi_d : \mathbb{R}^d \to \mathbb{R}^2 \) as an MLP (Multi-Layer Perceptron) that outputs a two-dimensional normalized vector. A core component of the PPO objective function is the clipped surrogate term, which constrains the policy change during the optimization process. Given a finite decomposition trajectory
\[(a_1, s_1), (a_2, s_2), \cdots, (a_T, s_T)\}\), we have
\[
L^{\text{clip}} = \mathbb{E}_t \Big[ \min \left( \rho_t, \text{clip}(\rho_t, 1 - \epsilon, 1 + \epsilon) \right) \hat{A}_t \Big],
\]
where \( \rho_t = \frac{\pi_d(a_t|s_t)}{\pi_{d^{\text{old}}}(a_t|s_t)} \) is a probability ratio to estimate the divergence between old and current policy. The hyperparameter \( \epsilon \) sets the clipping boundary for \( \rho \) to fall between \([1 - \epsilon, 1 + \epsilon]\). \( \hat{A}_t \) is the advantage at step \( t \) which measures how better taking the action \( a_t \) at state \( s_t \) is compared to the average value of the state.

To calculate the average value of a state, we create another trainable MLP as a value function, \( v : \mathbb{R}^d \to \mathbb{R} \), to map the state to its corresponding value. Then, we estimate the advantage \( \hat{A}_t \) using GAE (Generalized Advantage Estimator; Schulman et al. (2016)):
\[
\hat{A}_t = \delta_t + (\gamma \lambda) \delta_{t+1} + \cdots + (\gamma \lambda)^{T-t+1} \delta_{T-1},
\]
where \( \delta_t = r_t + \gamma v(s_{t+1}) - v(s_t) \).
\[(9)\]

\( r_t \) is the reward defined in Eq.7. \( \delta_t \) is the TD residual of value function with discount factor \( \gamma \) (Sutton and Barto, 1998). Another hyperparameter \( \lambda \) controls the trade-off between bias and variance in advantage estimation. We use the squared-error loss to train our value function: \( (v(s_t) - v_t^{\text{target}})^2 \approx (v(s_t) - (\hat{A}_t + v(s_t)))^2 = \hat{A}_t^2 \). Therefore, our final PPO objective function with entropy bonus term \( S[\pi_d](s_t) \) becomes:
\[
L^{\text{PPO}} = \mathbb{E}_t \Big[ L^{\text{clip}} - c_1 \hat{A}_t^2 + c_2 S[\pi_d](s_t) \Big],
\]
where \( c_1 \) and \( c_2 \) are coefficients. We perform gradient descent on \( -L^{\text{PPO}} \) to maximize the above objective function. Algorithm 1 outlines the procedure.

3 Experiment Setup

3.1 Dataset Construction

To evaluate the effect of decomposition policies on verification, we construct two claim datasets from FActScore (Min et al., 2023), whose original claims are sourced from ChatGPT (OpenAI, 2022) and PerplexityAI (AI, 2023).\footnote{For simplicity, we refer to each dataset by the name of its source LLM.} Each dataset contains claims with 6 different atomicities ranging from -1 to 4. Specifically, we consider the given human-annotated atomic subclaims as the base with atomicity 0, because they typically are self-contained sentences with single factual information (e.g., “The String is a collection of poetry”). We construct higher-level subclaims by recursively merging pairs at the same atomicity level from the base up until atomicity 4, which is the highest level that cannot be merged further. We also decompose the base subclaims to a lower level at atomicity -1, where subclaims are partially tautological (e.g., “String exists”, “String is a collection”, “The collection is composed of poetry”).\footnote{We use gpt-3.5-turbo-0125 to perform the decomposition and name the decomposition policy as FActScore-Atom whose prompt can be found in Appendix D.} Thus, each subclaim is purposefully built to contain 2atomicity pieces of information. We provide data statistics in Appendix B.1.

Algorithm 1 Train Dynamic Decomposition Policy

Input: decomposition LLM \( \mathcal{D} \), verification LLM \( \mathcal{V} \), decomposition policy \( \pi_d \), verification policy \( \pi_v \), value function \( v \), state transition model GRU, initial atomicity state \( s_0 \), claims \( \{C_i\} \) to be verified.

1: while not done do
    # update replay buffer
    2: for step = 1, \ldots, m do
        3: \( C \sim \{C_i\}, \{c_j\} = C, s_t = s_0 \)  # initialization
        4: while not finish decomposition do
            5: \( s_t \leftarrow \) start atomicity state
            6: \( c^* \leftarrow \text{BF Sampling} \ \{c_j\} \)  # get target subclaim
            7: \( a_t \leftarrow \) sample action from \( \pi_d(a_t | s_t) \)
            8: LLM \( \mathcal{D} \) decompose \( c^* \) following Eq.2
            9: \( \{c_j\} \leftarrow \) update subclaim list following Eq.3
            10: \( r_t \leftarrow \) reward from Eq.7
            11: \( s_{t+1} \leftarrow \) end atomicity state updated by Eq.4
            12: Record \( (a_t, r_t, s_t, s_{t+1}) \) into replay buffer \( R \)
        end while
    end for
    # train dynamic decomposition policy
    15: \( \pi_d^{\text{old}} \leftarrow \pi_d \)
    16: for each update step do
        17: Sample minibatch \( M \) from replay buffer \( R \)
        18: for each \( (a_t, r_t, s_t, s_{t+1}) \) in \( M \) do
            19: \( \hat{A}_t \leftarrow \) advantage from Eq.9
            20: \( \rho_t \leftarrow \frac{\pi_d(a_t|s_t)}{\pi_{d^{\text{old}}}(a_t|s_t)} \)
        end for
        22: \( L^{\text{clip}} \leftarrow \) clipped surrogate term from Eq.8
        23: \( L^{\text{PPO}} \leftarrow \) objective function from Eq.10
        24: Update \( \pi_d, v, \) GRU using \( -L^{\text{PPO}} \) through GD
    end for
end while
Verifiers Following Min et al. (2023), we determine factual labels by comparing the conditional probability of True and False from the verifier. We experiment the following three verification LLMs: a T5-3B (Raffel et al., 2023) fine-tuned on FActScore for the factuality verification task (FT-T5-3B), a Llama-7B (Touvron et al., 2023) trained on Super Natural Instructions (Wang et al., 2022) (Inst-Llama-7B), and a pre-trained and instruction tuned Llama3-8B model (Meta, 2024) (Llama3-Inst-8B). We employ three verification policies, each utilizing differently constructed prompts to assist verification: (1) Retrieval retrieves relevant passages from a database as evidence; (2) In-Context Example provides verification demonstrations to instruct verification;6 and (3) No-Context directly asks the verifier for predictions, as inspired by Kadavath et al. (2022).

3.3 Training

Initialization We model each policy and value function as a two-layer fully connected perceptron with a ReLU activation function (Agarap, 2019). The total number of trainable parameters is 4.73M. We perform binary decomposition on each subclaim during our dynamic decomposition, aligning with the definition of atomicity (using a logarithm with base 2), to ensure maximal exploration of the subclaim space. Please refer to Appendix B.3 for more details.

Data We train our policy on two constructed claim datasets across atomicity [1, 4].

Hyperparameters Please see Appendix B.4.

3.4 Baselines and Metrics

We compare our trained decomposition policy (hereafter denoted as DyDecomp) to existing decomposition policies, including FActScore (Min et al., 2023), WICE (Kamoi et al., 2023) and R-NID (Wanner et al., 2024), on both verification confidence (Eq.6) and accuracy (Eq.1). These works typically apply heuristic splitting prior to neural decomposition, thus their decomposition policies are primarily designed for subclaims under atomicity 2. To ensure a fair comparison, our evaluation is conducted on claims on atomicity within [0, 2]. We also evaluate DyDecomp against a modified version of the FActScore policy, FActScore-Atom, which is designed to decompose human-annotated atomic subclaims (atomicity 0) to partially trivial subclaims (atomicity -1) in §3.1.

4 Results and Analysis

We first study the effect of subclaim atomicity on verification (§4.1), followed by evaluating dynamic decomposition against existing baselines (§4.2) and ablation study (§4.4).

4.1 Effect of Subclaim Atomicity on Verification

Prior works have found that decomposition policy influences verification results and does not guarantee consistent verification improvement across varying input length and verifier strength (Jiang et al., 2024; Wanner et al., 2024; Hu et al., 2024). In this study, we take one step further by looking into the following two questions: How can we quantify the impact of decomposition policy on verification, and why does this influence not yield consistent improvements across different verifiers?

Why use verification confidence? Our experiment finds a strong correlation between verification confidence and accuracy across various conditions (Figure 2), including different datasets, atomicity levels, and verifiers. Additionally, verification confidence is more accessible than accuracy as it does not require ground-truth labels. These properties support verification confidence as a reliable metric for evaluating the impact of decomposition policies and as an ideal signal funneling back to policy.

Each verifier has its own atomicity optimum. We investigate how atomicity, a key characteristic of decomposed subclaims, affects verification. Figure 4 shows verification confidence change across different atomicity levels. We find that each verifier, which is a verification LLM with a specific verification policy, achieves peak verification confidence at a distinct optimal atomicity. For instance, Llama3-Inst-8B with a retrieval verification policy consistently performs best at atomicity 0 on both the ChatGPT and PerplexityAI datasets, whereas FT-T5-3B with retrieval reaches its optimum at atomicity 2. This observation answers the second question that the different preference for atomicity makes existing static decomposition policies hard to find optimal subclaims that bring consistent verification improvement.

6In-context examples can be found in Appendix D.
Figure 4: Verification confidence across atomicities. Evidently, each verifier has its own preferred input atomicity at which the verification confidence peaks. Even when utilizing the same verification policy, such as retrieval, different verifiers exhibit distinct preferences, and vice versa.

4.2 Dynamic Decomposition Results

Table 1 shows the evaluation results of decomposer Llama3-Inst-70B with DYDECOMP policy on various verifiers, datasets, and claim atomicities. Evidently, DYDECOMP consistently achieves the highest verification confidence for claims with atomicity 1 and 2, outperforming the four baselines by an average margin of 0.07. This result aligns with our findings from Figure 4, where the verification LLM for Table 1 (i.e., Llama3-Inst-8B) generally achieves the best performance at atomicity 0. In other words, an effective decomposition policy should strategically decompose claims to lower atomicities, ideally to 0, which is an ability our DYDECOMP excels. Conversely, since claims are already near optimal, DYDECOMP does not always achieve higher verification confidence than other baselines when atomicity = 0.

We also evaluate DYDECOMP on verification accuracy and observe a notable average improvement of 0.12 for claims from PerplexityAI with atomicity 1 and 2. We repeat the experiments with another decomposition LLM, DeepSeek-V3, and observe similar improvement in verification accuracy (see Table 5 in Appendix C).

4.3 Case Study

A critical question emerges when adopting verification confidence as a proxy for accuracy: whether the policy would over-optimize for confidence in ways that did not actually improve accuracy? Our findings indicate that this phenomenon does happen, primarily due to inherent limitations in verifier capabilities. As shown in Table 1, on the PerplexityAI dataset, we observe aligned improvements in both verification confidence and actual accuracy. However, the ChatGPT dataset demonstrates substantial gains in verifier confidence with only negligible improvements in accuracy.

We posit that the disparity stems from fundamental differences in verifier capability relative to data complexity. Specifically, we find claims in the ChatGPT dataset are generally more complex and less grounded than those in the PerplexityAI dataset, making them inherently more difficult to verify. In contrast, PerplexityAI claims are typically more concise and feature explicit reference through indexed citations, enabling even less capable verifiers (Llama3-Inst-8B in this case) to evaluate factuality with greater confidence and accuracy. We provide examples in Appendix B.2 to illustrate this difference.

Our observations indicate that verifier capability
<table>
  <tr>
    <th rowspan="2">Atomicity</th>
    <th rowspan="2">Decompose Policy → Verify Policy↓</th>
    <th colspan="2">FActScore</th>
    <th colspan="2">FActScore-Atom</th>
    <th colspan="2">WICE</th>
    <th colspan="2">R-NDC</th>
    <th colspan="2">DYDECOMP</th>
  </tr>
  <tr>
    <th>Verification Confidence [0-1]↑</th>
    <th>Verification Accuracy [0-1]↑</th>
    <th>Verification Confidence [0-1]↑</th>
    <th>Verification Accuracy [0-1]↑</th>
    <th>Verification Confidence [0-1]↑</th>
    <th>Verification Accuracy [0-1]↑</th>
    <th>Verification Confidence [0-1]↑</th>
    <th>Verification Accuracy [0-1]↑</th>
  </tr>
  <tr>
    <td rowspan="3">0</td>
    <td>Data Source: ChatGPT<br>Retrieval</td>
    <td>0.627 / 0.666</td>
    <td>0.618 / 0.796</td>
    <td>0.431 / 0.782</td>
    <td>0.556 / 0.449</td>
    <td>0.600 / 0.789</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td>In-Context Example</td>
    <td>0.677 / 0.454</td>
    <td>0.677 / 0.388</td>
    <td>0.724 / 0.451</td>
    <td>0.714 / 0.401</td>
    <td>0.715 / 0.428</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td>No-Context</td>
    <td>0.557 / 0.457</td>
    <td>0.526 / 0.566</td>
    <td>0.374 / 0.525</td>
    <td>0.527 / 0.378</td>
    <td>0.547 / 0.551</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td rowspan="3">0</td>
    <td>Data Source: PerplexityAI<br>Retrieval</td>
    <td>0.629 / 0.559</td>
    <td>0.611 / 0.755</td>
    <td>0.435 / 0.762</td>
    <td>0.541 / 0.241</td>
    <td>0.612 / 0.799</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td>In-Context Example</td>
    <td>0.681 / 0.266</td>
    <td>0.670 / 0.197</td>
    <td>0.726 / 0.308</td>
    <td>0.711 / 0.172</td>
    <td><b>0.733</b> / 0.301</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td>No-Context</td>
    <td>0.555 / 0.352</td>
    <td>0.515 / 0.471</td>
    <td>0.380 / 0.475</td>
    <td>0.519 / 0.166</td>
    <td>0.542 / <b>0.554</b></td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td rowspan="3">1</td>
    <td>Data Source: ChatGPT<br>Retrieval</td>
    <td>0.609 / 0.739</td>
    <td>0.611 / 0.815</td>
    <td>0.527 / 0.755</td>
    <td>0.541 / 0.635</td>
    <td><b>0.654</b> / 0.758</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td>In-Context Example</td>
    <td>0.714 / 0.635</td>
    <td>0.705 / 0.627</td>
    <td>0.658 / 0.631</td>
    <td>0.749 / 0.610</td>
    <td><b>0.809</b> / 0.609</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td>No-Context</td>
    <td>0.549 / 0.619</td>
    <td>0.521 / 0.550</td>
    <td>0.437 / 0.606</td>
    <td>0.508 / 0.610</td>
    <td><b>0.567</b> / 0.512</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td rowspan="3">1</td>
    <td>Data Source: PerplexityAI<br>Retrieval</td>
    <td>0.610 / 0.493</td>
    <td>0.615 / 0.68</td>
    <td>0.527 / 0.597</td>
    <td>0.515 / 0.232</td>
    <td><b>0.651</b> / 0.753</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td>In-Context Example</td>
    <td>0.721 / 0.247</td>
    <td>0.711 / 0.253</td>
    <td>0.684 / 0.27</td>
    <td>0.746 / 0.22</td>
    <td><b>0.791</b> / 0.347</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td>No-Context</td>
    <td>0.535 / 0.260</td>
    <td>0.506 / 0.350</td>
    <td>0.423 / 0.273</td>
    <td>0.506 / 0.223</td>
    <td><b>0.559</b> / 0.437</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td rowspan="3">2</td>
    <td>Data Source: ChatGPT<br>Retrieval</td>
    <td>0.616 / 0.844</td>
    <td>0.639 / 0.887</td>
    <td>0.588 / 0.809</td>
    <td>0.547 / 0.852</td>
    <td><b>0.644</b> / 0.652</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td>In-Context Example</td>
    <td>0.731 / 0.835</td>
    <td>0.725 / 0.835</td>
    <td>0.665 / 0.835</td>
    <td>0.744 / 0.835</td>
    <td><b>0.824</b> / 0.750</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td>No-Context</td>
    <td>0.553 / 0.809</td>
    <td>0.545 / 0.800</td>
    <td>0.507 / 0.835</td>
    <td>0.515 / 0.835</td>
    <td><b>0.583</b> / 0.509</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td rowspan="3">2</td>
    <td>Data Source: PerplexityAI<br>Retrieval</td>
    <td>0.622 / 0.483</td>
    <td>0.639 / 0.601</td>
    <td>0.592 / 0.546</td>
    <td>0.529 / 0.406</td>
    <td><b>0.633</b> / 0.664</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td>In-Context Example</td>
    <td>0.755 / 0.392</td>
    <td>0.734 / 0.378</td>
    <td>0.675 / 0.392</td>
    <td>0.751 / 0.392</td>
    <td><b>0.823</b> / 0.464</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td>No-Context</td>
    <td>0.543 / 0.378</td>
    <td>0.535 / 0.378</td>
    <td>0.492 / 0.392</td>
    <td>0.509 / 0.392</td>
    <td><b>0.544</b> / 0.421</td>
    <td></td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
</table>

Table 1: Comparison of our DYDECOMP over baselines on the test dataset. Each metric is scaled from 0 to 1. ↑ indicates higher values are preferred. We employ decomposition LLM Llama3-Inst-70B and verification LLM Llama3-Inst-8B. DYDECOMP consistently outperforms on atomicity 1 and 2, achieving an average improvement of 0.07 in verification confidence across two datasets and three verifiers, and a 0.12 average improvement in verification accuracy for claims sourced from PerplexityAI.

is a pivotal factor in the success of dynamic decomposition, exemplifying a “bucket effect” where the weakest component constrains system performance. When paired with a sufficiently strong verifier, the dynamic decomposition can optimize the entire system in tandem, ensuring that confidence improvements translate into genuine accuracy gains.

4.4 Ablation Study

Table 2 display our ablation study on different components of DYDECOMP regarding algorithm design and training data selection. We use the decomposition LLM Llama3-Inst-70B, and the verifier Llama3-8B-Inst with a retrieval verification policy. The ablation experiments are conducted on claims with atomicity 4.

Decomposition exploration is effective for long-form text verification. In experiment setup §3, we model each policy and value function as a two-layer perceptron. We investigate whether a simple, shallow model can capture the atomicity state and find that reducing the network to a single layer results in lower verification confidence for decomposed subclaims. Similarly, switching from binary to triple decomposition at each step, which reduces the exploration of subclaims on different atomicities, also leads to declined verification confidence. Furthermore, removing the entropy bonus term, which promotes action exploration, from the objective function leads to a substantial drop in verification confidence (-0.090). These findings demonstrate that DYDECOMP benefits from diverse decomposition trajectories during training, which facilitate the search for subclaims with optimal

<table>
  <tr>
    <th>Variants</th>
    <th>Verification Confidence</th>
  </tr>
  <tr>
    <td>DYDECOMP</td>
    <td>0.446</td>
  </tr>
  <tr>
    <td>— one layer NN</td>
    <td>0.398 (-0.048)</td>
  </tr>
  <tr>
    <td>— binary: + triple decompose</td>
    <td>0.424 (-0.022)</td>
  </tr>
  <tr>
    <td>— entropy bonus</td>
    <td>0.356 (-0.090)</td>
  </tr>
  <tr>
    <td>— data on atomicity 1</td>
    <td>0.353 (-0.093)</td>
  </tr>
  <tr>
    <td>— data on atomicity 1, 2</td>
    <td>0.356 (-0.090)</td>
  </tr>
  <tr>
    <td>— data on atomicity 1, 2, 3</td>
    <td>0.401 (-0.045)</td>
  </tr>
</table>

Table 2: Ablation study results of DYDECOMP. “—” indicates the removal of a component from DYDECOMP. For instance, “— one layer NN” means modeling the policy and value functions using a single-layer perceptron instead of two layers. “— data on atomicity 1” removes claims with atomicity 1 from the training data.
atomicity.

Cross-atomicity training data stabilizes performance. In Table 2, we train DYDECOMP using claims with atomicity ranging from 0 to 4 and evaluate on atomicity 4. We find that gradually removing claims of lower atomicity (from 1 to 3) from the training set negatively impacts verification performance, highlighting the importance of cross-atomicity data for improving the generalizability of DYDECOMP. However, this negative effect diminishes as more data with irrelevant atomicities is removed (\( -0.093 \rightarrow -0.045 \)). This suggests that increased exposure to claims of a specific atomicity during PPO rollouts enhances learning for that atomicity but cannot fully compensate for performance losses due to reduced atomicity coverage in training data.

5 Related Works

5.1 Decompose-Then-Verify Paradigms

Unlike traditional fact-checking systems that focus on short and simple claims (Thorne et al., 2018; Sathe et al., 2020; Schuster et al., 2021; Chen et al., 2022; Guo et al., 2022), Decompose-Then-Verify now becomes a typical approach in long-form text evaluation works, as it allows for more precise error identification and enhances the accuracy of verification by decomposing claims into shorter subclaims, which can then be independently validated (Min et al., 2023; Chern et al., 2023; Kamoi et al., 2023; Chen et al., 2023; Iqbal et al., 2024; Song et al., 2024; Chen et al., 2024a; Wang et al., 2024). However, how the decomposition and verification should be conducted is always underspecified.

Decomposition policies. Existing factuality evaluation works have proposed various decomposition prompts revealing different characteristics of textual decomposition regarding precision (Min et al., 2023), verifiability (Song et al., 2024), coverage (Wanner et al., 2024), and atomicity (Stacey et al., 2024). More recently, research has found that superficially fine-grained subclaims with trivial information could easily inflate verification precision (Jiang et al., 2024), and decomposition benefits weaker verifiers more than stronger verifiers by generating simpler subclaims (Hu et al., 2024). Our dynamic decomposition effectively addresses the over-optimization problem by providing necessary controllability over the decomposition process.

Moreover, static decomposition policies may struggle to handle input claims with varying fact density and often produce atomically homogeneous subclaims. We elaborate on these limitations in Appendix A.

Verification policies. Policies for verification can be categorized according to the methods verifiers utilize to process subclaims and predict final labels. Popular processing methods include retrieving relevant evidence (Kamoi et al., 2023; Wei et al., 2024), constructing in-context exemplars (Kamoi et al., 2023; Song et al., 2024), generating claim-focused summarization (Chen et al., 2024a), and simply zero-shot prompting (Kadavath et al., 2022; Min et al., 2023). The final label can be predicted by either gradient-based approaches (e.g., comparing logits of factual labels) (Chen et al., 2024a; Tang et al., 2024; Milbauer et al., 2023; Kamoi et al., 2023; Min et al., 2023) or searching for keywords (e.g., True or False) (Min et al., 2023; Li et al., 2024; Song et al., 2024).

5.2 RL in NLP Problems

Prior works have validated the use of RL in optimizing singular-task systems, such as identifying optimal exemplars for in-context learning (Zhang et al., 2022; Lu et al., 2023; Chen et al., 2024b). However, how RL can be applied to dual-task systems where multiple LLMs are involved remains under-explored. One concurrent work uses two LLMs as process reward and policy models, employing PPO to train them jointly for challenging reasoning tasks (Cui et al., 2025). In contrast, our dynamic decomposition first explores RL to solve a bilevel optimization problem in another dual-task system, Decompose-Then-Verify, to reveal the nuanced characteristics of hierarchical LLM systems through their interactions.

6 Conclusion

We find that each verifier has an optimal atomicity where its verification confidence peaks. To leverage it, we introduce dynamic decomposition that optimizes claim verification by decomposing claims into verifier-preferred atomicity learned via on-policy optimization. Our policy stands out for its adaptability to diverse verifiers and input claim atomicities, outperforming existing baselines while adding only 4.73M parameters.
Limitations

Different characteristics of decomposition. While dynamic decomposition addresses the problem of misalignment between decomposer and verifier, we focus on the aspect of information density (i.e., atomicity). Although well-structured, self-contained, and verifiable subclaims could further improve verification, these aspects are beyond the scope of this paper. Future research could investigate other key characteristics of decomposition and explore how to amplify their positive effects on verification through dynamic decomposition (e.g., using a more powerful decomposer).

Evaluation metrics. Our reward design relies on verification confidence rather than accuracy. We leave it for future works to acquire more ground-truth labels to effectively employ verification accuracy as feedback.

Acknowledgments

This work was supported by NSF IIS-2119531, IIS-2137396, IIS-2142827, IIS-2234058, CCF-1901059, and ONR N00014-22-1-2507. The authors would like to thank Chihiro Taguchi, Katsumi Ibaraki and Demetrius Hernandez for their helpful input on earlier versions of this work. GPU machines for conducting experiments were provided by CRC cluster (https://crc.nd.edu/).

References

Abien Fred Agarap. 2019. Deep learning using rectified linear units (relu). Preprint, arXiv:1803.08375.

Perplexity AI. 2023. Perplexity.ai. https://www.perplexity.ai/.

Jiangjie Chen, Qiaoben Bao, Changzhi Sun, Xinbo Zhang, Jiaze Chen, Hao Zhou, Yanghua Xiao, and Lei Li. 2022. Loren: Logic-regularized reasoning for interpretable fact verification. Proceedings of the AAAI Conference on Artificial Intelligence, 36(10):10482–10491.

Jifan Chen, Grace Kim, Aniruddh Sriram, Greg Durrett, and Eunsol Choi. 2024a. Complex claim verification with evidence retrieved in the wild. In Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), pages 3569–3587. Mexico City, Mexico. Association for Computational Linguistics.

Shiqi Chen, Yiran Zhao, Jinghan Zhang, I-Chun Chern, Siyang Gao, Pengfei Liu, and Junxian He. 2023. Felm: Benchmarking factuality evaluation of large language models. Preprint, arXiv:2310.00741.

Tongfei Chen, Zhengping Jiang, Adam Poliak, Keisuke Sakaguchi, and Benjamin Van Durme. 2020. Uncertain natural language inference. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 8772–8779, Online. Association for Computational Linguistics.

Yunmo Chen, Tongfei Chen, Harsh Jhamtani, Patrick Xia, Richard Shin, Jason Eisner, and Benjamin Van Durme. 2024b. Learning to retrieve iteratively for in-context learning. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, pages 7156–7168, Miami, Florida, USA. Association for Computational Linguistics.

I-Chun Chern, Steffi Chern, Shiqi Chen, Weizhe Yuan, Kehua Feng, Chunting Zhou, Junxian He, Graham Neubig, and Pengfei Liu. 2023. Factool: Factuality detection in generative ai – a tool augmented framework for multi-task and multi-domain scenarios. Preprint, arXiv:2307.13528.

Kyunghyun Cho, Bart van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. 2014. Learning phrase representations using RNN encoder–decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 1724–1734, Doha, Qatar. Association for Computational Linguistics.

Ganqu Cui, Lifan Yuan, Zefan Wang, Hanbin Wang, Wendi Li, Bingxiang He, Yuchen Fan, Tiantyu Yu, Qixin Xu, Weize Chen, Jiurui Yuan, Huayu Chen, Kaiyan Zhang, Xingtai Lv, Shuo Wang, Yuan Yao, Xu Han, Hao Peng, Yu Cheng, Zhiyuan Liu, Maosong Sun, Bowen Zhou, and Ning Ding. 2025. Process reinforcement through implicit rewards. Preprint, arXiv:2502.01456.

DeepSeek-AI. 2024. Deepseek-v3 technical report. Preprint, arXiv:2412.19437.

Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, Minneapolis, Minnesota. Association for Computational Linguistics.

Logan Engstrom, Andrew Ilyas, Shibani Santurkar, Dimitris Tsipras, Firdaus Janoos, Larry Rudolph, and Aleksander Madry. 2019. Implementation matters in deep policy gradients: A case study on ppo and trpo. In iclr.

Zhijiang Guo, Michael Schlichtkrull, and Andreas Vlachos. 2022. A survey on automated fact-checking. Transactions of the Association for Computational Linguistics, 10:178–206.
Pierre Hansen, Brigitte Jaumard, and Gilles Savard. 1992. New branch-and-bound rules for linear bilevel programming. SIAM Journal on Scientific and Statistical Computing, 13(5):1194–1217.

Qisheng Hu, Quanyu Long, and Wenya Wang. 2024. Decomposition dilemmas: Does claim decomposition boost or burden fact-checking performance? Preprint, arXiv:2411.02400.

Hasan Iqbal, Yuxia Wang, Minghan Wang, Georgi Nenkov Georgiev, Jiahui Geng, Iryna Gurevych, and Preslav Nakov. 2024. Open-FactCheck: A unified framework for factuality evaluation of LLMs. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pages 219–229, Miami, Florida, USA. Association for Computational Linguistics.

Zhengping Jiang, Jingyu Zhang, Nathaniel Weir, Seth Ebner, Miriam Wanner, Kate Sanders, Daniel Khashabi, Anqi Liu, and Benjamin Van Durme. 2024. Core: Robust factual precision with informative sub-claim identification. Preprint, arXiv:2407.03572.

Saurav Kadavath, Tom Conerly, Amanda Askell, Tom Henighan, Dawn Drain, Ethan Perez, Nicholas Schiefer, Zac Hatfield-Dodds, Nova DasSarma, Eli Tran-Johnson, Scott Johnston, Sheer El-Shouk, Andy Jones, Nelson Elhage, Tristan Hume, Anna Chen, Yuntao Bai, Sam Bowman, Stanislav Fort, Deep Ganguli, Danny Hernandez, Josh Jacobson, Jackson Kernion, Shauna Kravec, Liane Lovitt, Kamal Ndousse, Catherine Olsson, Sam Ringer, Dario Amodei, Tom Brown, Jack Clark, Nicholas Joseph, Ben Mann, Sam McCandlish, Chris Ohah, and Jared Kaplan. 2022. Language models (mostly) know what they know. Preprint, arXiv:2207.05221.

Ryo Kamoi, Tanya Goyal, Juan Diego Rodriguez, and Greg Durrett. 2023. Wice: Real-world entailment for claims in wikipedia. Preprint, arXiv:2303.01432.

Itay Levy, Ben Bogin, and Jonathan Berant. 2023. Diverse demonstrations improve in-context compositional generalization. In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1401–1422, Toronto, Canada. Association for Computational Linguistics.

Miaoran Li, Baolin Peng, Michel Galley, Jianfeng Gao, and Zhu Zhang. 2024. Self-checker: Plug-and-play modules for fact-checking with large language models. In Findings of the Association for Computational Linguistics: NAACL 2024, pages 163–181, Mexico City, Mexico. Association for Computational Linguistics.

Pan Lu, Liang Qiu, Kai-Wei Chang, Ying Nian Wu, Song-Chun Zhu, Tanmay Rajpurkar, Peter Clark, and Ashwin Kalyan. 2023. Dynamic prompt learning via policy gradient for semi-structured mathematical reasoning. In International Conference on Learning Representations (ICLR).

Meta. 2024. The llama 3 herd of models. Preprint, arXiv:2407.21783.

Jeremiah Milbauer, Ziqi Ding, Zhijin Wu, and Tongshuang Wu. 2023. NewsSense: Reference-free verification via cross-document comparison. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pages 422–430, Singapore. Association for Computational Linguistics.

Sewon Min, Kalpesh Krishna, Xinxi Lyu, Mike Lewis, Wen-tau Yih, Pang Koh, Mohit Iyyer, Luke Zettlemoyer, and Hannaneh Hajishirzi. 2023. FActScore: Fine-grained atomic evaluation of factual precision in long form text generation. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 12076–12100, Singapore. Association for Computational Linguistics.

Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. 2016. Asynchronous methods for deep reinforcement learning. In Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pages 1928–1937, New York, New York, USA. PMLR.

Aaron Mueller, Albert Webson, Jackson Petty, and Tal Linzen. 2024. In-context learning generalizes, but not always robustly: The case of syntax. In Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), pages 4761–4779, Mexico City, Mexico. Association for Computational Linguistics.

OpenAI. 2022. Chatgpt blog post. https://openai.com/index/chatgpt/.

M.L. Puterman. 2014. Markov Decision Processes: Discrete Stochastic Dynamic Programming. Wiley Series in Probability and Statistics. Wiley.

Shuang Qiu, Zhuoran Yang, Jieping Ye, and Zhaoran Wang. 2021. On finite-time convergence of actor-critic algorithm. IEEE Journal on Selected Areas in Information Theory, 2(2):652–664.

Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. 2023. Exploring the limits of transfer learning with a unified text-to-text transformer. Preprint, arXiv:1910.10683.

Aalok Sathe, Salar Ather, Tuan Manh Le, Nathan Perry, and Joonsook Park. 2020. Automated fact-checking of claims from Wikipedia. In Proceedings of the Twelfth Language Resources and Evaluation Conference, pages 6874–6882, Marseille, France. European Language Resources Association.

John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. 2016. High-dimensional continuous control using generalized advantage estimation. In iclr.
John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. 2017. Proximal policy optimization algorithms. Preprint, arXiv:1707.06347.

Tal Schuster, Adam Fisch, and Regina Barzilay. 2021. Get your vitamin C! robust fact verification with contrastive evidence. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 624–643, Online. Association for Computational Linguistics.

Ankur Sinha, Pekka Malo, and Kalyanmoy Deb. 2018. A review on bilevel optimization: From classical to evolutionary approaches and applications. IEEE Transactions on Evolutionary Computation, 22(2):276–295.

Yixiao Song, Yekyung Kim, and Mohit Iyyer. 2024. VeriScore: Evaluating the factuality of verifiable claims in long-form text generation. In Findings of the Association for Computational Linguistics: EMNLP 2024, pages 9447–9474, Miami, Florida, USA. Association for Computational Linguistics.

Joe Stacey, Pasquale Minervini, Haim Dubossarsky, Oana-Maria Camburu, and Marek Rei. 2024. Atomic inference for NLI with generated facts as atoms. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, pages 10188–10204, Miami, Florida, USA. Association for Computational Linguistics.

R.S. Sutton and A.G. Barto. 1998. Reinforcement learning: An introduction. IEEE Transactions on Neural Networks, 9(5):1054–1054.

Liyan Tang, Philippe Laban, and Greg Durrett. 2024. MiniCheck: Efficient fact-checking of LLMs on grounding documents. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, pages 8818–8847, Miami, Florida, USA. Association for Computational Linguistics.

James Thorne, Andreas Vlachos, Christos Christodoulopoulos, and Arpit Mittal. 2018. FEVER: a large-scale dataset for fact extraction and VERification. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 809–819, New Orleans, Louisiana. Association for Computational Linguistics.

Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, Aurelien Rodriguez, Armand Joulin, Edouard Grave, and Guillaume Lample. 2023. Llama: Open and efficient foundation language models. Preprint, arXiv:2302.13971.

Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. In Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc.

Yizhong Wang, Swaroop Mishra, Pegah Alipoormolabashi, Yeganeh Kordi, Amirreza Mirzaei, Atharva Naik, Arjun Ashok, Arut Selvan Dhanasekaran, Anjana Arunkumar, David Stap, Eshaan Pathak, Giannis Karamanolakis, Haizhi Lai, Ishan Purohit, Ishani Mondal, Jacob Anderson, Kirby Kuznia, Krima Doshi, Kuntal Kumar Pal, Maitreyaa Patel, Mehrad Moradshahi, Mihir Parmar, Mirali Purohit, Neeraj Varshney, Phani Rohitha Kaza, Pulkit Verma, Ravsehaj Singh Puri, Rushang Karia, Savan Doshi, Shailaja Keyur Sampat, Siddhartha Mishra, Sujan Reddy A, Sumanta Patro, Tanay Dixit, and Xudong Shen. 2022. Super-NaturalInstructions: Generalization via declarative instructions on 1600+ NLP tasks. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing, pages 5085–5109, Abu Dhabi, United Arab Emirates. Association for Computational Linguistics.

Yuxia Wang, Revanth Gangi Reddy, Zain Muhammad Mujahid, Arnav Arora, Aleksandr Rubashevskii, Jiahui Geng, Osama Mohammed Afzal, Liangming Pan, Nadav Borenstein, Aditya Pillai, Isabelle Augenstein, Iryna Gurevych, and Preslav Nakov. 2024. Factcheck-bench: Fine-grained evaluation benchmark for automatic fact-checkers. Preprint, arXiv:2311.09000.

Miriam Wanner, Seth Ebner, Zhengping Jiang, Mark Dredze, and Benjamin Van Durme. 2024. A closer look at claim decomposition. Preprint, arXiv:2403.11903.

Jerry Wei, Chengrun Yang, Xinying Song, Yifeng Lu, Nathan Hu, Jie Huang, Dustin Tran, Daiyi Peng, Ruibo Liu, Da Huang, Cosmo Du, and Quoc V. Le. 2024. Long-form factuality in large language models. Preprint, arXiv:2403.18802.

Yiming Zhang, Shi Feng, and Chenhao Tan. 2022. Active example selection for in-context learning. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing, pages 9134–9148, Abu Dhabi, United Arab Emirates. Association for Computational Linguistics.
Supplemental Material

<table>
  <tr>
    <th>Appendix</th>
    <th>Contents</th>
  </tr>
  <tr>
    <td><a href="#">Appendix A</a></td>
    <td>Limitations of Static Decomposition Policies</td>
  </tr>
  <tr>
    <td><a href="#">Appendix B</a></td>
    <td>Additional Details of Experimental Setup</td>
  </tr>
  <tr>
    <td><a href="#">Appendix C</a></td>
    <td>Additional Details of Experimental Results</td>
  </tr>
  <tr>
    <td><a href="#">Appendix D</a></td>
    <td>Used Prompts</td>
  </tr>
  <tr>
    <td><a href="#">Appendix E</a></td>
    <td>Example</td>
  </tr>
</table>

A  Limitations of Static Decomposition Policies

Static decomposition demonstrations hardly handle input with varying fact density. Song et al. (2024) find that the factual score evaluated on one task (e.g., biography generation) does not necessarily correlate with the one evaluated on different tasks (e.g., long-form QA), which have different input atomicities. Similar issues have also been revealed in other compositional tasks, such as semantic parsing, where static ICL demonstrations have unreliable performance on out-of-distribution data (Levy et al., 2023; Mueller et al., 2024). Thus, existing decomposition policies that rely on static demonstrations, including FActScore (Min et al., 2023), WICE (Kamoi et al., 2023), R-ND (Wanner et al., 2024), and SAFE (Wei et al., 2024), may struggle to handle input claims with varying fact densities or atomicities.

Subclaims are atomically homogeneous and not optimized for downstream verifiers. There is a prevailing assumption made in prior works that verification performance is expected to increase as input complexity decreases (Min et al., 2023; Wei et al., 2024; Hu et al., 2024). Therefore, they leverage in-context demonstrations to establish uniformly low atomicity among all generated subclaims, which barely accommodate downstream verifiers based on our findings.

Our dynamic decomposition is the first solution to tackle these limitations by explicitly exploring various decomposition complexities during training. As a result, it achieves a more generalizable performance and consistently outperforms static methods across varying input atomicities.

B  Experiment Setup

B.1  Data Preparation

We first split the given FActScore dataset into train (60%), validation (20%), and test (20%) sets. Subclaims are then recursively constructed,7 with each atomicity level having its own train, validation, and test sets. We present the number of claims per atomicity in Table 3.

<table>
  <tr>
    <th rowspan="2">Atomicity→<br>Data Source↓</th>
    <th colspan="6">4</th>
  </tr>
  <tr>
    <th>4</th>
    <th>3</th>
    <th>2</th>
    <th>1</th>
    <th>0</th>
    <th>-1</th>
  </tr>
  <tr>
    <td>ChatGPT</td>
    <td>89</td>
    <td>251</td>
    <td>578</td>
    <td>1239</td>
    <td>4886</td>
    <td>2482</td>
  </tr>
  <tr>
    <td>PerplexityAI</td>
    <td>116</td>
    <td>289</td>
    <td>661</td>
    <td>1405</td>
    <td>5568</td>
    <td>2842</td>
  </tr>
</table>

Table 3: Statistics of constructed subclaim datasets.

Note that we do not use subclaims with atomicity -1 during training because they are already over-decomposed. Thus only the test set at atomicity 0 is decomposed to get subclaims at −1, resulting in fewer instances at atomicity -1 compared to at 0.

7We use the same protocol as in Eq.1 to label new subclaims: a claim is true only if all its subclaims are true.
B.2 Data Example

Data from ChatGPT

Quintus Sosius Senecio was a Roman senator and military commander who lived during the 2nd century AD. He was a member of the senatorial class and served in various high-ranking positions in the Roman government, including as consul in 128 AD.

In addition to his political career, Quintus Sosius Senecio was also a distinguished military leader. He served as a legate (commander) in several provinces, including Africa and Pannonia, and was awarded triumphal honors for his victories over the enemies of Rome.

Quintus Sosius Senecio was also known for his literary works, including a history of the Roman Empire, which unfortunately has not survived to the present day.

Overall, Quintus Sosius Senecio was a prominent figure in Roman society, known for his military prowess, political acumen, and intellectual pursuits.

Data from PerplexityAI

Quintus Sosius Senecio was a Roman consul who lived during the 1st and 2nd centuries AD[1]. He was married to Julia, the daughter of Frontinus, a prominent Roman civil engineer, author, soldier, and senator[3]. Quintus Sosius Senecio was the father of Sosia Polla[1], who married Quintus Pompeius Falco, a consul in AD 109[4].

Quintus Sosius Senecio was a friend of Plutarch, a Greek Middle Platonist philosopher, historian, biographer, essayist[2]. Plutarch wrote about several Roman nobles in his works including Quintus Sosius Senecio and Titus Avidius Quietus[2].

B.3 Training Initialization

We initialize our atomicity state as a zero vector with dimension size 768 and set the bias of the update gate in GRU to \(-\infty\). This is because Chen et al. (2024b) found that using an identity function in state transition helps stabilize RL training. We use BERT (Devlin et al., 2019) to obtain embeddings for Eq.4, where subclaims are concatenated using the [SEP] token.\footnote{https://huggingface.co/google-bert/bert-base-uncased} We employ an UNLI model (Chen et al., 2020) to estimate the conditional probability \(P(\cdot \mid \mathcal{H})\) in Eq.5.\footnote{https://huggingface.co/Zhengping/roberta-large-unli} Following Jiang et al. (2024), we use these bleached contextual claims showed in Table 4 as \( \mathcal{H} \).

<table>
  <tr>
    <th>Claim Template</th>
  </tr>
  <tr>
    <td>\( \${TOPIC} \) is a person.<br>
      \( \${TOPIC} \) breathes.<br>
      \( \${TOPIC} \) exists.<br>
      \( \${TOPIC} \) is a name.<br>
      \( \${TOPIC} \) is unique.<br>
      \( \${TOPIC} \) is famous.<br>
      \( \${TOPIC} \) has some abilities.<br>
      somebody knows \( \${TOPIC} \).<br>
      \( \${TOPIC} \) is a star.
    </td>
  </tr>
</table>

Table 4: Bleached claim set designed for FActScore-style biography evaluation.

We provide our binary decomposition prompt in Appendix D. Similar to (Cui et al., 2025), we employ online trajectory filtering, which filters out trajectories based on a predefined reward mean threshold.

B.4 Hyperparameters

For decomposition, we set the sampling temperature to 0.2 during training to encourage exploration and use 0 during evaluation for better reproducibility. We consistently set the temperature to 0 for verification.
For PPO training, we use the following hyperparameters: \( \epsilon = 0.2, \gamma = 0.99, \lambda = 0.95, c_1 = 0.02, c_2 = 0.005 \). We configure the replay buffer size to 512 steps, the rollout batch size to 32 samples, the maximum decomposition trajectory length to 20 steps, the mini-batch size to 32, and the trajectory filter threshold to -0.02. We use the learning rate \( 3e^{-5} \) together with a cosine-annealing learning rate scheduler. The model is trained for 100 steps, with validation performed every 10 steps, and the best-performing model is saved. Training is conducted on 2 NVIDIA RTX A6000 GPUs, requiring approximately 80 GPU hours.
C Experiment Results

How much data is needed for training a dynamic decomposition policy? Given DYDECOMP requires iterative online practice to determine optimal atomicity, it is natural to ask how much data is required to train an effective DYDECOMP policy. The results are presented in Figure 5, where we trained six DYDECOMP policies using varying amounts of training data. A training data ratio of 1 represents the dataset size used in our main experiment. We observe that DYDECOMP with on-policy learning can achieve promising and comparable performance even with a limited amount of data. Generally, DYDECOMP performance improves with increased training data, particularly on claims with lower atomicity, but begins to oscillate after reaching a certain data threshold (e.g. 0.75).

![Verification results on ChatGPT dataset](page_246_384_956_246.png)
(a) Verification results on ChatGPT dataset

![Verification results on PerplexityAI dataset](page_246_635_956_246.png)
(b) Verification results on PerplexityAI dataset

Figure 5: The verification sensitivity of dynamic decomposition as the training data size changes. The five figures (from left to right) represent claims with atomicity in the range [0, 4], evaluated under DYDECOMP policy trained on different dataset sizes. The horizontal dashed line denotes verification confidence for original claims without decomposition. We use decomposition LLM Llama3-Inst-70B and verification LLM Llama3-Inst-8B with retrieval verification policy.

![Average information loss measures across training steps](page_246_1017_956_246.png)

Figure 6: Average information loss measures across training steps on the validation set. Clearly, it decreases as the model continues training and learning to decompose claims into more atomic levels. This trend aligns with our design motivation outlined in Eq.5: as claims become syntactically closer to bleached claims through decomposition, the resulting information loss diminishes accordingly.
<table>
  <tr>
    <th rowspan="2">Atomicity</th>
    <th rowspan="2">Decompose Policy → Verify Policy↓</th>
    <th colspan="2">FActScore</th>
    <th colspan="2">FActScore-Atom</th>
    <th colspan="2">WICE</th>
    <th colspan="2">R-NDC</th>
    <th colspan="2">DYDECOMP</th>
  </tr>
  <tr>
    <th colspan="2">Verification Confidence [0-1] ↑</th>
    <th colspan="2">Verification Accuracy [0-1] ↑</th>
    <th colspan="2"></th>
    <th colspan="2"></th>
    <th colspan="2"></th>
  </tr>
  <tr>
    <td rowspan="3">0</td>
    <td><i>Data Source: PerplexityAI</i></td>
    <td>Retrieval</td>
    <td>0.702 / 0.844</td>
    <td>0.655 / 0.770</td>
    <td>0.705 / 0.856</td>
    <td>0.700 / 0.802</td>
    <td>0.685 / 0.820</td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td></td>
    <td>In-Context Example</td>
    <td>0.741 / 0.309</td>
    <td>0.702 / 0.197</td>
    <td>0.757 / 0.334</td>
    <td>0.730 / 0.283</td>
    <td><b>0.757</b> / 0.323</td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td></td>
    <td>No-Context</td>
    <td>0.593 / 0.522</td>
    <td>0.557 / 0.454</td>
    <td>0.600 / 0.553</td>
    <td>0.600 / 0.463</td>
    <td>0.580 / 0.507</td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td rowspan="3">1</td>
    <td><i>Data Source: PerplexityAI</i></td>
    <td>Retrieval</td>
    <td>0.694 / 0.740</td>
    <td>0.685 / 0.717</td>
    <td>0.690 / 0.760</td>
    <td>0.681 / 0.673</td>
    <td>0.680 / 0.780</td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td></td>
    <td>In-Context Example</td>
    <td>0.754 / 0.260</td>
    <td>0.743 / 0.247</td>
    <td>0.763 / 0.273</td>
    <td>0.749 / 0.230</td>
    <td><b>0.768</b> / 0.333</td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td></td>
    <td>No-Context</td>
    <td>0.583 / 0.310</td>
    <td>0.561 / 0.337</td>
    <td>0.563 / 0.347</td>
    <td>0.591 / 0.290</td>
    <td>0.569 / 0.457</td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td rowspan="3">2</td>
    <td><i>Data Source: PerplexityAI</i></td>
    <td>Retrieval</td>
    <td>0.706 / 0.692</td>
    <td>0.695 / 0.650</td>
    <td>0.700 / 0.671</td>
    <td>0.675 / 0.622</td>
    <td>0.656 / 0.679</td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td></td>
    <td>In-Context Example</td>
    <td>0.749 / 0.385</td>
    <td>0.748 / 0.385</td>
    <td>0.763 / 0.385</td>
    <td>0.747 / 0.385</td>
    <td><b>0.802</b> / 0.400</td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
  <tr>
    <td></td>
    <td>No-Context</td>
    <td>0.594 / 0.364</td>
    <td>0.586 / 0.385</td>
    <td>0.586 / 0.371</td>
    <td>0.587 / 0.385</td>
    <td>0.564 / 0.386</td>
    <td></td>
    <td></td>
    <td></td>
  </tr>
</table>

Table 5: Comparison of our DYDECOMP over baselines on the testing set. Each metric is scaled from 0 to 1. ↑ indicates higher values are preferred. We employ decomposition LLM DeepSeek-V3 and verification LLM Llama3-Inst-8B. DYDECOMP consistently outperforms baselines on verification accuracy across various verifiers and input claim atomicities.

D Prompts

Binary Decomposition

[system] You are a decomposer. Your task is to decompose the given claim into two sub-claims. There are two principles you have to follow: 1) making sure there is no information loss or gain after decomposition and 2) making sure each generated subclaim is self-contained and approximately equal in length and information. Separate the two subclaims with a hyphen.

[user] Following the given two principles, please decompose the following claim into two sub-claims: In 1963, Collins became one of the third group of astronauts selected by NASA and he served as the back-up Command Module Pilot for the Gemini 7 mission.
- Collins became one of the third group of astronauts selected by NASA in 1963.
- Collins served as the back-up Command Module Pilot for the Gemini 7 mission.

Following the given two principles, please decompose the following claim into two sub-claims: In addition to his acting roles, Bateman has written and directed two short films and is currently in development on his feature debut.
- In addition to his acting roles, Bateman has written and directed two short films.
- Bateman is currently in development on his feature debut.

Following the given two principles, please decompose the following claim into two sub-claims: "Parasite" received widespread critical acclaim for its screenplay, direction, acting, and its social commentary.
- "Parasite" received widespread critical acclaim for its screenplay and direction.
- "Parasite" received widespread critical acclaim for its acting and social commentary.

Following the given two principles, please decompose the following claim into two sub-claims: {claim}
FActScore-Atom Decomposition Policy

[system] You are a decomposer. Your task is to decompose the given claim into more granular subclaims. There are two principles you have to follow: 1) making sure there is no information loss or gain after decomposition and 2) making sure each generated subclaim is self-contained. Separate the decomposed subclaims with a hyphen

[user] Following the given two principles, please decompose the following claim into more granular subclaims: He made his acting debut in the film The Moon is the Sun’s Dream.
- He made his acting debut.
- Debut happened in the film.
- The Moon is the Sun’s Dream is a film.

Following the given two principles, please decompose the following claim into more granular subclaims: He has worked with a wide variety of artists.
- He worked.
- It happened with a wide variety of artists.

Following the given two principles, please decompose the following claim into more granular subclaims: Bateman has directed two short films.
- Bateman had directed films.
- There are two films.
- Films are short.

Following the given two principles, please decompose the following claim into more granular subclaims: {claim}

In-Context Examples Verification Policy

[system] Your task is to verify the correctness of the given claim. Only answer with 'True' or 'False'.

[user] Input: In 1996, he was awarded the Ig Nobel Prize for Art, an award given to honor achievements that make people laugh, and then think. True or False?
Output: True
Input: Featherstone's pink flamingo design was displayed at the Smithsonian National Museum of American History in 1996, and he was inducted into the Plastics Hall of Fame in 1998. True or False?
Output: False
Input: Featherstone continued to work on his designs until his death in 2015, and his creations remain popular among collectors and enthusiasts of Americana. True or False?
Output: False
Input: Travis Oliphant is a data scientist and entrepreneur who is best known for creating the NumPy and SciPy libraries for Python programming language. True or False?
Output: True
Input: He was born on August 22, 1972, in the United States. True or False?
Output: False
E Example

<table>
  <tr>
    <th>Method</th>
    <th>Results</th>
  </tr>
  <tr>
    <td>Original</td>
    <td>After retiring from tennis in 1996, Sabatini pursued other interests, including fashion and fragrance design. She also established the Gabriela Sabatini Foundation, which supports children's education and sports programs in Argentina.</td>
  </tr>
  <tr>
    <td rowspan="8">FactScore (Min et al., 2023)</td>
    <td>1. Sabatini retired from tennis in 1996.<br>2. After retiring from tennis, Sabatini pursued other interests.<br>3. Sabatini pursued fashion design.<br>4. Sabatini pursued fragrance design.<br>5. Sabatini established the Gabriela Sabatini Foundation.<br>6. The Gabriela Sabatini Foundation supports children's education.<br>7. The Gabriela Sabatini Foundation supports sports programs.<br>8. The Gabriela Sabatini Foundation supports children's education and sports programs in Argentina.</td>
  </tr>
  <tr>
    <td>1. Sabatini retired from tennis.<br>2. Sabatini’s retirement from tennis occurred in 1996.<br>3. Sabatini pursued other interests after retiring.<br>4. Sabatini’s other interests include fashion.<br>5. Sabatini’s other interests include fragrance design.<br>6. Sabatini established the Gabriela Sabatini Foundation.<br>7. The Gabriela Sabatini Foundation supports children's education.<br>8. The Gabriela Sabatini Foundation supports sports programs.<br>9. The Gabriela Sabatini Foundation operates in Argentina.<br>10. Sabatini’s establishment of the foundation occurred after her retirement.<br>11. Sabatini’s pursuit of other interests occurred after her retirement.</td>
  </tr>
  <tr>
    <td>1. Sabatini retired from tennis in 1996.<br>2. Sabatini pursued other interests after retiring.<br>3. Sabatini’s interests included fashion design.<br>4. Sabatini’s interests included fragrance design.<br>5. Sabatini established the Gabriela Sabatini Foundation.<br>6. The Gabriela Sabatini Foundation supports children's education in Argentina.<br>7. The Gabriela Sabatini Foundation supports sports programs in Argentina.</td>
  </tr>
  <tr>
    <td>1. After retiring from tennis in 1996, Sabatini pursued other interests, including fashion and fragrance design.<br>2. Sabatini established the Gabriela Sabatini Foundation, which supports children’s education and sports programs in Argentina.</td>
  </tr>
</table>

Table 6: Example of decomposition results from different methods, where we use DeepSeek-V3 as the decomposer. Our DYDECOMP policy is trained for the verifier Llama3-Inst-8B with No-Context policy.
We provide an example in Table 6 to show the differences between subclaims decomposed using our DY-DECOMP policy and those derived from popular decomposition methods. For the verifier Llama3-Inst-8B using No-Context verification policy, which according to Figure 4 has the best verification performance at atomicity level 2 (i.e., input contains 4 pieces of atomic information). Evidently, only our trained DYDECOMP policy successfully generates subclaims that closely match the verifier’s preferred atomicity level. These examples highlight how existing decomposition methods can lead to suboptimal performance in fact-checking systems.

Reviewer paper summaries: This paper mainly investigating the Decompose-Then-Verify paradigm for claim verification and emphasize the misalignment between existing decomposer and verifier.  The authors introduce atomicity to quantify sub-claim information density and propose verification confidence as a proxy for sub-claim accuracy. The misalignment mainly arises because prompt-based decomposition policies fail to produce subclaims with optimal atomicity, leading to suboptimal verification performance. The authors frame the problem as a bilevel optimization problem and to approximates a solution, they propose DYDECOMP, a reinforcement learning-based claim decomposition framework that learns a dynamic decomposition policy tailored to the verifier’s preferences. Specifically, the approach models decomposition as a Markov Decision Process, training a lightweight policy model to decide when to continue decomposition.  Empirical results demonstrate that the DYDECOMP outperforms static, hand-crafted decomposition policies by improving verification confidence and accuracy across various verification settings and claim atomicities.

This paper examines the Decompose-Then-Verify paradigm in claim fact-checking and identifies a misalignment between the decomposition step and the verification step. The authors introduce *subclaim atomicity* as a novel metric to quantify information density in decomposed subclaims, and they observe that different verifiers have distinct optimal atomicity levels for input subclaims. To address the misalignment, the paper formulates finding an optimal decomposition policy as a bilevel optimization problem and proposes dynamic decomposition – a reinforcement learning framework that uses verifier feedback to iteratively adjust how claims are broken down. This learned decomposition policy adapts the granularity of subclaims to the verifier’s preferred atomicity and yields improved verification performance (with average boosts of ~0.07 in confidence and ~0.12 in accuracy over baselines) across diverse verification settings.

This paper looks into what makes a good decomposition of claims and proposes a RL-based framework with verifier as feedback for dynamic decomposition
Summary of strengths: 1. Novel Use of Reinforcement Learning for Claim Decomposition: I believe this work is among the first to apply reinforcement learning (RL) to optimize claim decomposition dynamically. Unlike many prior approaches that rely on static, hand-crafted prompts, the proposed DYDECOMP framework learns an adaptive decomposition policy.

2. Well-Defined Atomicity Metric and Bilevel Optimization Formulation: The paper introduces 'atomicity' as a formal metric for sub-claim information density. While prior work has leveraged the concept of atomicity, this study clearly defines and quantifies it, distinguishing it from heuristic-based approaches. Additionally, framing claim decomposition as a bilevel optimization task is well-motivated, and the proposed actor-critic RL solution offers a principled approach to adaptive decomposition.

3. Clear Illustration and Solid Experiment: The authors clearly articulate the RL-based approach and conduct comprehensive experiments,  comparing multiple baselines to demonstrate the effectiveness of their proposed framework.

Overall, I believe this work is novel and quite solid, a valuable contribution to the field.

- The paper tackles an important but previously overlooked issue – the interaction between claim decomposition and verification. It introduces *atomicity* as a new measure of subclaim granularity and shows that existing one-size-fits-all decomposition strategies can be suboptimal. This insight is novel and provides a clear motivation for an adaptive approach.

- The proposed dynamic decomposition framework is technically sound and innovative. By framing the problem as a reinforcement learning task, the authors let the decomposer learn from the verifier’s feedback in order to produce optimally granular subclaims. This is an elegant solution to a complex bilevel optimization (NP-hard) problem. 
- The paper demonstrates strong experimental results. Dynamic decomposition consistently outperforms static, hand-crafted decomposition policies in verification tasks, yielding notable gains in verifier confidence and accuracy. The improvements are observed across multiple datasets or settings with varying claim complexity.

1. This is the first paper to me, that focues on this perspective.
2. The narrative of the paper sounds reasonable
Summary of weaknesses: More discussion can be added to ample the following points:

1. Limited Generalizability Across Verifiers: I understand the proposed method learns decomposition policies tailored to specific verifiers, it would be beneficial for the authors to further discuss its generalizability to unseen verification models.

2. Lack of Qualitative Analysis on Decomposed Subclaims: More qualitative examples of the decomposed subclaims across different atomicity levels can be helpful.

3. Verification Confidence as a Proxy for Accuracy: This point is minor as the paper provides empirical justification, it would be still better if authors can add more discussion regarding the choice of proxy for accuracy.

- The study focuses primarily on optimizing information density (atomicity) of subclaims, while other quality aspects of decomposed claims are not addressed. For example, ensuring subclaims are self-contained, non-redundant, and phrased in a verifiable manner could further impact verification. 

- The reinforcement learning agent is rewarded based on the verifier’s confidence score rather than the ground-truth verification accuracy. Although the authors note a strong correlation between confidence and actual correctness, this proxy could be imperfect. In cases where a verifier’s confidence is miscalibrated, the decomposition policy might receive misleading feedback. Did the authors observe any cases of the agent over-optimizing for confidence in ways that didn’t actually improve correctness (e.g., producing overly trivial subclaims that trivially get high confidence)? 
- Incorporating an RL-based decomposer increases the system’s complexity compared to using a fixed prompt-based decomposition. Training the decomposition policy requires additional data or interactions with the verifier. 
- It’s not fully discussed how well a policy trained for one verifier or domain would transfer to another. If a new verification model is introduced, the decomposition policy might need retraining to adapt to the new preferred atomicity, which could limit out-of-the-box generalization.

1. I think more specific examples should be demonstrated for easy understanding.
2. The evaluate data source comes from only FActScore. I think it is relative single. As I know FActScore contains only claims with simple logic, while in many other claim verification tasks, claim usually contains much more complicated logics (nested logic for example). In complex scenarios, i doubt if your reward design, the difference between `Confidence` would work. Because nested-logic claim first are hard to decompse to be completely indepentent, and if subclaims are verified independently, the results of verifier are also doubtful.
Comments, suggestions and typos: Please see weaknesses.

See above.

null
Overall assessment scores: 4

4

3