#  ACCORD: Closing the Commonsense Measurability Gap

François Roewer-Després1,4 Jinyue Feng1,4 Zining Zhu,4 Frank Rudzicz3,4
1University of Toronto 2Stevens Institute of Technology 3Dalhousie University
4Vector Institute for Artificial Intelligence
{francoisrd<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>

###### Abstract

We present ACCORD, a framework and benchmark suite for disentangling the
commonsense grounding and reasoning abilities of large language models (LLMs)
through controlled, multi-hop counterfactuals. ACCORD introduces formal
elements to commonsense reasoning to explicitly control and quantify reasoning
complexity beyond the typical 1 or 2 hops. Uniquely, ACCORD can automatically
generate benchmarks of arbitrary reasoning complexity, and so it scales with
future LLM improvements. Benchmarking state-of-the-art LLMs shows performance
degrading to random chance with only moderate scaling, leaving substantial
headroom for improvement. We release a leaderboard111Leaderboard and dataset
download: https://www.codabench.org/competitions/3160/ of the benchmark suite
tested in this work, as well as code222Source code:
https://github.com/francois-rd/accord for automatically generating more
complex benchmarks.

##  1 Introduction

LLMs perform remarkably well on diverse reasoning tasks [1, 2, 3]. However,
more detailed analysis reveals their reasoning remains unreliable [4, 2, 3, 5,
6, 7, 8, 9, 10, 11, 12, 13]. LLM reasoning often lacks robustness to simple
lexical triggers [7] or irrelevant context [14, 15, 16, 17, 18, 19, 20]. In
Chain-of-Thought (CoT) approaches, LLMs can decompose problems into illogical
or irrelevant reasoning chains [2, 3, 8, 9], and can systematically
rationalize incorrect conclusions based on a simple reordering of answer
choices [13]. Furthermore, these limitations appear to worsen as the reasoning
complexity increases [10, 12].

Separately, LLMs are increasingly being used as knowledge bases (KBs) [21, 22]
given their impressive ability to store knowledge in model parameters [23, 18,
24, 25, 26, 27, 28, 29, 30, 31, 32]. However, this ability incurs limitations,
including hallucinations [33, 6, 10, 34, 35], inconsistency [36, 13], and
outdated knowledge [18, 26, 37, 38, 34, 31]. As such, grounding LLMs with
contextual knowledge during inference has become a leading paradigm [23, 24,
25, 26, 27, 28, 29, 30, 32] — for example, in retrieval-augmented generation
[39, 40, 41, 34, 42]. However, LLMs tend to integrate contextual knowledge
unfaithfully [43, 24, 44, 27, 29, 30, 32], especially when parametric and
contextual knowledge conflict [23, 18, 24, 7, 45, 28, 30].

Unfortunately, context unfaithfulness confounds empirical measurements of
reasoning, leading to construct validity concerns [46, 47, 8]. Indeed, LLMs
can circumvent the intended objective of various reasoning tasks using
inductive biases from parametric knowledge [23, 8, 48, 12], dataset artifacts
[49, 13], and other spurious shortcuts [46, 50, 51, 36, 47, 7, 8, 52, 13, 53].
More formally, borrowing from Wu et al. [48], we conceptualize a default world
model, $w^{\text{default}}$, as the set of conditions and assumptions
underpinning the vast majority of LLM training data. Under this view, LLMs can
circumvent $w^{\text{default}}$-grounded reasoning tasks precisely because
they are trained on $w^{\text{default}}$ data [48].

Counterfactual Definition Example Hypothetical Runs counter to scenario;
plausible under $w^{\text{default}}$ A bird flies over a bridge [scenario].
What would have happened if the bird had hit the bridge? [54] Anti-factual
Implausible under $w^{\text{default}}$ If cats were vegetarians, cats would
love cabbages. [7]

Table 1: Differentiating hypothetical from anti-factual counterfactuals.
$w^{\text{default}}$ is a model of the default (i.e., commonsense) worldview
underpinning the majority of existing LLM training data [48].

Rules:

$\texttt{part\\_of}(x,y)\land\texttt{spatial}(y,z)\Rightarrow\texttt{spatial}(x,z)$

Facts:

$\texttt{part\\_of}(hydrogen,water~{}molecule)$

$\texttt{spatial}(water~{}molecule,ocean)$

Conclusion:

$\texttt{spatial}(hydrogen,ocean)$

(a) Formal Reasoning

Rules:

<implied commensensically>

Facts:

hydrogen is part of water molecules

water molecules appear near oceans

Conclusion:

hydrogen appears near oceans

(b) Commonsense Reasoning

Figure 1: Differentiating formal from commonsense reasoning. Formal reasoning
requires systematically applying formal rules, which must be provided
explicitly [4]. Commonsense relies on informal reasoning to fill in knowledge
gaps, which is more ill-defined and therefore more challenging [4, 55].

Fortunately, counterfactual grounding, in which (at least some) contextual
knowledge runs counter to $w^{\text{default}}$, can mitigate this concern [54,
56, 24, 57, 58, 7, 45, 28, 9, 48, 30, 59, 53]. However, the effectiveness of
counterfactual grounding depends on the degree to which LLMs cease resorting
to parametric shortcuts. To illustrate this point, we distinguish between two
types of counterfactuals (see Table 1): hypothetical, in which the context
runs counter to a specific scenario but remains plausible under
$w^{\text{default}}$; and anti-factual (AF), in which the context is
implausible under $w^{\text{default}}$. LLMs are less likely to spuriously
solve anti-factuals compared to hypotheticals precisely because the former are
implausible under $w^{\text{default}}$ and are thus significantly stronger
inductive bias mitigators [48].

Reasoning is generally categorized into sub-types [4, 42, 60], most of
which—including analogical, mathematical, logical, and symbolic reasoning—are
types of formal reasoning that follows systematic rules and logical processes
[4]. All knowledge needed to solve formal reasoning problems must be provided
as explicit rules (see Figure 1(a)). In contrast, commonsense reasoning relies
on informal reasoning to fill in knowledge gaps based on intuition and worldly
experience (see Figure 1(b)) [4, 55]. This makes commonsense reasoning well-
suited to our goal, since LLMs learn this worldly experience via pretraining
on $w^{\text{default}}$, which is prone to grounding confounds [48].
Commonsense reasoning has a broad scope, and its boundaries are vague and ill-
defined [55]. As a result, it can generally be understood as a catch-all term
for all non-formal reasoning. However, “non-formal” does not imply a lack of
reasoning complexity [55]. Indeed, commonsense reasoning tasks aim to test
this informal reasoning ability. However, as established above,
$w^{\text{default}}$-grounded tasks cannot distinguish between genuine
reasoning ability and mere parametric parroting of a suitable common knowledge
solution.

In this work, we present ACCORD, a framework for generating Anti-faCtual
COmmonsense Reasoning Disentanglement benchmarks. ACCORD tightly controls
fine-grained anti-factual variants of commonsense reasoning tasks to enable
detailed analysis of LLM performance factors. Since the lack of formal rules
renders controlled analysis of commonsense reasoning particularly challenging,
ACCORD borrows from formal reasoning to partially formalize commonsense
reasoning. In so doing, ACCORD disentangles commonsense grounding and
reasoning abilities in LLMs, while explicitly controlling and quantifying
reasoning complexity—a feature ubiquitous in formal reasoning benchmarks, but
overwhelmingly lacking in commonsense reasoning benchmarks [55]. In this way,
ACCORD takes a significant step towards closing the commonsense measurability
gap with respect to formal reasoning.

Moreover, ACCORD is uniquely designed to generate future benchmarks of
arbitrary reasoning complexity with minimal additional human effort, and, as
such, automatically scales its difficulty level in tandem with future
improvements in LLM abilities. Our experiments on state-of-the-art LLMs show
performance degrading to below random chance with only moderate scaling,
leaving substantial headroom for improvement. We release a leaderboard of
these benchmarks, as well as code for automatically generating more
challenging benchmarks as LLM abilities improve.

##  2 ACCORD Framework

Figure 2: The ACCORD framework applied to a QA dataset. Top row: Manual
preprocessing of chosen dataset. Bottom: Fully automated steps based on this
preprocessing. (1) Generate all possible reasoning trees. (2) Pair each QA
instance to all matching trees. (3) Find all $n$-hop reasoning paths. (4) For
each path, duplicate the tree for each answer choice, then anti-factually
ground variables. Legend: s, p, t in the abstractions are shorthands for
spatial, part_of, and type_of, respectively.

ACCORD generates an anti-factual benchmark from an existing
$w^{\text{default}}$-grounded commonsense dataset (see Table 1 for the
definition of $w^{\text{default}}$). In this work, we frame our discussion
around multiple-choice question (MCQ) datasets. In principle, ACCORD extends
to other task modalities. Consider a question-answer (QA) instance from a
dataset $D$ with question $q$ and $w^{\text{default}}$ correct answer
$a^{\text{default}}$ from among answer choices
$\boldsymbol{a}=\\{a_{1},a_{2},\ldots,a_{Q}\\}$. Answering
$a^{\text{default}}$ given $q$ and $\boldsymbol{a}$ presumably requires
$w^{\text{default}}$-based commonsense reasoning. However, as discussed in §1,
spurious shortcuts may circumvent such reasoning. To overcome this hurdle, we
introduce an anti-factual context $C^{\text{af}}$, which consists of
statements aligned to some anti-factual world, $w^{\text{af}}\neq
w^{\text{default}}$. Specifically, $C^{\text{af}}$ is constructed to ensure
some alternative answer choice $a^{\text{af}}\neq a^{\text{default}}$ is
implied. ACCORD aims to systematically examine LLM performance given
$C^{\text{af}}$. To what extent, if any, is LLM performance affected by
reasoning errors or context unfaithfulness? Does reasoning complexity play a
role? The crux of ACCORD lies in the careful design of variants of
$C^{\text{af}}$ to tease these factors apart.

###  2.1 Generating Reasoning Trees

Reasoning Skill Definition ConceptNet Reasoning Template Name Spatial X
appears near Y AtLocation $\mathbf{X}$ appears near $\mathbf{Y}$ spatial Cause
& Effect X causes Y Causes $\mathbf{X}$ causes $\mathbf{Y}$ causal Has Parts X
contains Y as one of its parts PartOf $\mathbf{Y}$ is a part of $\mathbf{X}$
part_of Is Member Of X belongs to the larger class of Y IsA $\mathbf{X}$ is a
type of $\mathbf{Y}$ type_of Purpose X is the purpose of Y UsedFor
$\mathbf{Y}$ is used for $\mathbf{X}$ used_for Preconditions X must hold true
for Y to take place HasPrerequisite $\mathbf{Y}$ has prerequisite $\mathbf{X}$
requires

Table 2: Subset of reasoning skills and definitions identified by Talmor et
al. 61, along with a mapping to an appropriate ConceptNet [62] relation and
associated named reasoning template (our work).

In order to rigorously quantify the differences between variants of
$C^{\text{af}}$, we construct its surface form (i.e., its natural language
textual form) from a formalized underlying structured called a reasoning tree
(see Figure 2). A reasoning tree consists of reasoning templates. Each
reasoning template is an abstraction derived from a specific reasoning skill,
which is a recurring pattern of commonsense reasoning [61]. For example, the
spatial reasoning skill (see Table 2) is the pattern of understanding which
objects commensensically appear at which locations (e.g., “an instrument
appears near a music store”) [61]. Each template also maps its skill to a
surface form with placeholder variables for concepts. For example, the spatial
template may have the surface form “$\mathbf{X}$ appears near $\mathbf{Y}$”,
where $\mathbf{X}$ and $\mathbf{Y}$ are variables that can be grounded (e.g.,
$\mathbf{X}\leftarrow$ instrument and $\mathbf{Y}\leftarrow$ music store).

To construct a reasoning tree, reasoning templates are composed (i.e., linked
together) via their variables (see Figure 2). This creates a reasoning graph
with variables as nodes and templates as edges. ACCORD operates on this graph
to rigorously enforce construct validity. For example, ACCORD constrains the
reasoning graph to contain no cycles (hence, the more precise term “reasoning
tree”). This acyclicity ensures reasoning trees do not entail reasoning
paradoxes (e.g., “$\mathbf{X}$ contains $\mathbf{Y}$; $\mathbf{Y}$ contains
$\mathbf{Z}$; $\mathbf{Z}$ contains $\mathbf{X}$”). The tree is converted it
to its surface form only for the LLMs.

In a reasoning tree with $T$ templates, we connect two specific variables (see
§2.2 for details) via a reasoning path (see Figure 2). We define reasoning
complexity as the number of templates, $n$, along this path, which matches the
definition of reasoning hops in the multi-hop reasoning literature (e.g.,
[49]). We use the terms interchangeably. The $d$ templates outside a reasoning
path are distractors. Note that $T=n+d$ by construction. LLM performance in
formal reasoning tasks tends to decrease as $n$ and $T$ increase [10], and is
rarely robust to distractors [14, 15, 16, 17, 18, 19, 20]. As noted in §4,
ACCORD is unique among commonsense benchmarks in its ability to precisely
quantify non-trivial $n$ and $d$ values, which empowers us to study whether
these trends apply to commonsense as well (see §3).

Consecutive pairs of templates along a reasoning path must reduce to some
valid reasoning skill (see Figure 2). Figure 1(a) demonstrates the reduction
between part_of and spatial. Reducibility ensures that templates are composed
commensensically, rather than arbitrarily. Indeed, validating any particular
pair of reasoning skills requires commonsense, since not all pairs are
reducible. For example, whereas part_of and spatial are reducible, spatial and
causal are not—just because something is near a cause does not mean it is also
near its effect. See Figure 3 for additional examples.

###  2.2 Grounding Reasoning Trees

spatial causal part_of type_of used_for requires s s s s s s c c u c c p p p t
u r t u u u $>$ $\rightarrow$ Permutation r r $\leftarrow$ $<$ Legend

Case $>$:
$\texttt{row}(x,y)\land\texttt{col}(z,y)\Rightarrow\texttt{reduction}(x,z)$

Case $\rightarrow$:
$\texttt{row}(x,y)\land\texttt{col}(y,z)\Rightarrow\texttt{reduction}(x,z)$

Case $\leftarrow$:
$\texttt{row}(y,x)\land\texttt{col}(z,y)\Rightarrow\texttt{reduction}(z,x)$

Case $<$:
$\texttt{row}(y,x)\land\texttt{col}(y,z)\Rightarrow\texttt{reduction}(x,z)$

Figure 3: Reduction Matrix. For each pair of reasoning skills (row then
column), there are four permutations of the ordering of the variables $x$,
$y$, and $z$. For each case, we manually determine whether a reduction is
entailed, and, if so, its type (shown here as the first letter of the skill
name). For example, Figures 1 and 4 illustrate case ‘$\leftarrow$’ of spatial
$\land$ part_of. Since cases are symmetric, only the upper triangle is shown.

Instruction:

You will be provided with statements relating to a multiple-choice question.
The contents of the statements may disagree with your prior knowledge of the
world. That is ok. Your task is to provide the most appropriate answer to the
multiple-choice question based on the reasoning presented in the statements.

Statements:

Suppose that [pay debts] is a part of [forest]

Suppose that [forest] does not appear near [the planet]

Suppose that [galaxy] is a part of [coat]

Suppose that [coat] does not appear near [the planet]

Suppose that [outer space] is a part of [watch]

Suppose that [watch] does appear near [the planet]

Suppose that [orbit] is a part of [story]

Suppose that [story] does not appear near [the planet]

Suppose that [universe] is a part of [egg]

Suppose that [egg] does not appear near [the planet]

Question:

Where is the first place someone leaving the planet ends up?

Answer choices:

A: pay debts B: galaxy C: outer space D: orbit E: universe

Figure 4: Factual reasoning (with anti-factual grounding) from
ACCORD${}_{\text{CSQA}}^{2}$. Careful negation ensures exactly one answer
choice is implied while mitigating lexical matching bias. Statements are shown
ordered for human legibility.

In §2.1, we generate diverse reasoning trees with reasoning skills that are
internally consistent. However, an arbitrary tree is unlikely to feature
reasoning skills relevant to any particular QA instance from the underlying
dataset $D$. For example, the question in Figure 4 ($q=$ “Where is the first
place someone leaving the planet ends up?”) is related to the spatial skill
(e.g., “What appears near the planet?”), but completely unrelated to the
causal skill. To ensure relevance, we pair each QA instance only to those
reasoning trees matching at least one of the instance’s pairing templates.
Pairing templates share all properties of reasoning templates, except that one
of their variables, the pairing variable, $\mathbf{V}_{p}$, is grounded with a
specific term, the pairing term (see Figure 2). Pairing templates are hand-
crafted such that they uniquely discriminate between the answer choices,
$\boldsymbol{a}$, of a given question, $q$.333Although pairing templates are
hand-crafted, this human effort is, by design, highly reusable because a
single pairing template can pair a given QA instance to an arbitrary number of
trees of arbitrary complexity. Specifically, each pairing template has a
positive variant, $p^{+}$, which can imply any given answer choice, $a_{i}$,
and a negative variant, $p^{-}$ which can contradict $a_{i}$. More precisely,
all variables in all reasoning tree templates are eventually anti-factually
grounded except the pairing variable (see details below). As discussed in §1,
such anti-factual grounding mitigates the spurious shortcuts that may
otherwise circumvent factually-grounded reasoning. To experimentally verify
this potential for spurious shortcuts, we hold all other factors equals, while
allowing the choice of $a_{i}$ to be factual (i.e.,
$a_{i}=a^{\text{default}}$), which reinforces $w^{\text{default}}$ and can
enable shortcuts, or to be anti-factual (i.e., $a_{i}\neq
a^{\text{default}}$), which (implicitly) implies some anti-factual world,
$w^{\text{af}}_{i}\neq w^{\text{default}}$, that is highly unlikely to be
spuriously circumventable. For our running example from Figure 4, the pairing
template is “$\mathbf{X}$ does {not} appear near [the planet]”, where
$\mathbf{V}_{p}\leftarrow$ the planet and “{not}” represents the negative
variant. Using any of the answer choices, $\boldsymbol{a}$ = [pay debts,
galaxy, outer space, orbit, universe], with $p^{+}$ implies that answer
choice, whereas the same substitution in $p^{-}$ contradicts it. Since
$a^{\text{default}}=\texttt{outer space}$, matching outer space with $p^{+}$
or $p^{-}$ represents the factual or anti-factual variant of the same problem,
respectively. Figure 4, therefore, is factual.

For a given QA instance, we define a reasoning path as a sequence of templates
in a paired tree whose (recursively applied) reductions originate or terminate
with a pairing template (see Figure 2). The reasoning path thus connects a
source variable with a (possibly distant) target variable. Due to its
recursive construction, $\mathbf{V}_{p}$ will necessarily be either the source
or the target of the reasoning path. The variable at the other end is termed
the answer variable, $\mathbf{V}_{a}$. By the nature of recursive
reducibility, grounding $\mathbf{V}_{a}\leftarrow a_{i}$ necessarily implies
(or contradicts, for $p^{-}$) that $a_{i}$ answers $q$. However, implication
(or contradiction) of any one particular $a_{i}$ does not guarantee soundness
for the entire QA instance. In particular, if only one $a_{i}$ appears in its
context, an LLM may “guess” that $a_{i}$ is the intended answer through simple
lexical matching, thereby spuriously circumventing the intended reasoning task
via test-taking meta-reasoning [46, 57, 7]. To mitigate this potential bias,
we reduplicate the reasoning tree, once for each $a_{i}$, which ensures all
are present in the context while holding all else equal (see Figure 2).
Finally, we negate the reasoning path of all but one tree to ensure that
exactly one $a_{i}$ is implied, while all others are contradicted (e.g., see
Figure 4).444In principle, each $a_{i}$ could have its own pairing template,
or at least its own pairing term. However, it becomes nearly impossible to
programmatically ensure soundness across the entire QA instance. In contrast,
having all else being equal except negation ensures much cleaner mutual
exclusivity of the answer choices.

For each duplicated tree corresponding to $a_{i}$, we ground $\mathbf{V}_{p}$
with the pairing term $\mathbf{V}_{a}$ with $a_{i}$. From these two seed
terms, we anti-factually ground all other variables using a backtracking beam
tree search algorithm (see Figure 2). Essentially, these seed terms, along
with the skill types of the templates, place constraints on neighbouring
variables. These constraints filter out potential candidates drawn from an
external KB. To fit users’ compute budget, we keep only the top $k$ potential
candidates according to some relevance metric, thereby growing the frontier of
grounded variables. Obvious choices for the relevance metric include: semantic
distance between the seed and candidate terms, likelihood of the candidate as
computed by some LLM, or random sampling. We backtrack through unsatisfiable
constraints until all variables are grounded, resulting in multiple highly-
related trees that, crucially, share the same reasoning structure but have
different (anti-factual) grounding.

Finally, each template in each tree is converted to its respective natural
language surface form. Several factors are employed to mitigate dataset
artifacts. The order of the resulting statements, both within and between
reasoning trees, is randomized to mitigate any potential systematic effects
(such of recency bias). Duplicate statements are also removed, so as not to
bias LLM reasoning towards them.

##  3 Experiments

We apply ACCORD to CommonsenseQA (CSQA) [61] to create the
ACCORD${}_{\text{CSQA}}$ benchmark suite.555The supplemental material provides
additional details on ACCORD${}_{\text{CSQA}}$, including an expanded
discussion on the reduction matrix entries and pairing templates, as well as
societal impact and additional results. We choose CSQA due to its popularity
as a commonsense reasoning dataset. However, ACCORD is robust and equally
applicable to other commonsense reasoning datasets, such as CommonsenseQA 2.0
[63], OpenBookQA [64], and StrategyQA [65]. CSQA derives from ConceptNet [62],
an open graph of general commonsense knowledge. As such, we employ ConceptNet
as our grounding KB. Talmor et al. 61 manually identified reasoning skills
needed to answer CSQA questions (see Table 2), which we employ in
ACCORD${}_{\text{CSQA}}$ for consistency. For each skill, we find an
appropriate matching ConceptNet relation and devise and name a reasoning
template. We omit the social, activity, and definition skills due to lack of a
suitably matching ConceptNet relation.

For each pair of skills, we manually determine its reduction (if any) and keep
only those pairs whose reduction is both (a) valid and (b) closed under the
set of skills (see Figure 3). Due to the informal nature of commonsense
reasoning, we determine validity based on unanimous consensus among authors
rather than formal proofs. The closure constraint is a practical consideration
to speed up the algorithm, as it removes recursive dead ends in which
unverifiable reasoning paths are generated. Specifically, closure naturally
ensures reasoning paths of any length always have corresponding entries in the
reduction matrix lookup table.

For each instance in the CSQA development set, we infer the ConceptNet
relation that generated the instance by computing the majority vote among all
ConceptNet assertions matching one of its answer choices to its source concept
(see [61] for details). The resulting distribution is highly skewed, with 607
instances of ConceptNet’s AtLocation relation (the most popular) compared with
13 instances of IsA (the least popular). To balance ACCORD${}_{\text{CSQA}}$,
we randomly subsample each relation type, keeping only 13. Of the $6\times
13=78$ instances, we reject two due to inciting violence, and another two
where we cannot craft a valid pairing template. The baseline,
ACCORD${}_{\text{CSQA}}^{0}$, consists of the remaining 74 instances. We hand-
craft 1$-$3 pairing templates for these 74 instances, resulting in 93 pairing
templates. From these 93 pairings, we generate reasoning trees of sizes 1$-$5,
producing a suite of benchmarks, ACCORD${}_{\text{CSQA}}^{1-5}$, with 245,514
unique total trees and a guaranteed minimum of 143 unique trees per pairing.
To reduce computational costs while ensuring wide coverage, we subsample the
trees to keep precisely one tree per unique combination of reasoning hops and
distractors per pairing, which produced a smaller benchmark with 2,864 unique
trees. We present results from this smaller benchmark in Figure 5, but release
both versions of our benchmark.

Figure 5: Performance of state-of-the-art LLMs on ACCORD${}_{\text{CSQA}}$.
Left: Both factual and anti-factual performance degrade rapidly with
increasing reasoning hops, which is expected. Middle: Both factual and anti-
factual performance increase with increasing distractors, which is unexpected.
Right: Disentangling the interaction effect between reasoning hops and
distractors. Reasoning hops are dominant while distractors’ effect is
negligible, which explains the reversed trend in (Middle) when marginalizing
over reasoning hops. All: Factual significantly outperforms anti-factual,
which indicates context unfaithfulness. Anti-factual performance drops below
random chance as a result. Wald standard error bars are with respect to the 93
pairings, not reruns based on random seeds.

To anti-factually ground variables in these reasoning trees, we retrieve
assertions from ConceptNet. Consider a template with reasoning skill type
$r(\mathbf{X},\mathbf{Y})$. For a given seed term $s$, assume without loss of
generality that $s$ is the first term: $r(s,\mathbf{Y})$. We retrieve
assertions from ConceptNet table $r$, producing a list of factual assertions
of the form $r(x_{i},y_{i})$. Therefore, excluding any assertions where
$x_{i}=s$ ensures retrieval is purely anti-factual. That is, we set
$\mathbf{Y}\leftarrow y_{i}$ for some $y_{i}$ such that $r(x_{i},y_{i})$ is in
ConceptNet, but $r(s,y_{i})$ is not. Whenever a single candidate variable
links to multiple seed terms, we take the set intersection of all retrieved
assertions. Finally, we randomly sample $k=1$ term from these assertions. In
this way, variables are grounded within appropriate constraints based on skill
type, $r$, rather than completely arbitrarily. Still, the LLMs we benchmark
tend to refuse answering anti-factual questions, likely because most have
post-hoc constraints to curtail misinformation. To overcome this issue, we
introduce a simple instruction prompt that encouraged these LLMs to accept
anti-factual contexts. However, we emphasize that prompt engineering is not
the focus of this work. Figure 4 illustrates a sample from
ACCORD${}_{\text{CSQA}}^{2}$, including the instruction prompt.

Figure 5 shows the performance of GPT-4o (2024-05-13) [66],
Llama-3-70B-Instruct [67], and Mixtral-8x22B-Instruct-v0.1 [68] on
ACCORD${}_{\text{CSQA}}$ in a zero-shot setting. Crucially, and unlike prior
commonsense benchmarks, ACCORD quantifies performance as a function of problem
size, $T$, reasoning hops, $n$, and distractors, $d$, where $T=n+d$ (see
§2.1). Simultaneously, ACCORD disentangles grounding and reasoning effects
through comparing $w^{\text{default}}$-aligned and (i.e., factual) and
$w^{\text{af}}$-aligned (i.e., anti-factual) reasoning. The “No Context”
baseline represents ACCORD${}_{\text{CSQA}}^{0}$. Interestingly, performance
for factual $n=1$ (Column 1) exceeds this baseline for all three LLMs. We
postulate this occurs because the noisiness of base CSQA adds significant
difficulty to the task [3, 2], yet having a single reasoning hop reinforces
the factual answer choice in the most straightforward manner possible, which
helps LLMs cut through that noise. On the other hand, for $n>1$, both factual
and anti-factual performance degrade rapidly with increasing $n$. This trend
has been understood in formal reasoning [10], but we demonstrate it here for
the first time with commonsense as well.

Interestingly, the trend for distractors, $d$, (Column 2) is reversed, which
goes against expectations [15, 20]. This occurs because reasoning hops and
distractors are complementary for a given problem size ($T=n+d$), and, as
such, interact very strongly. Column 3 illustrates this interaction effect.
Specifically, when controlling for distractors, reasoning hops have a dominant
effect on the trend. On the other hand, increasing distractors only slightly
shifts the entire trend line downward. In other words, given a fixed $T$
(i.e., a fixed context budget), LLMs tend to prefer a smaller $n$ and larger
$d$ than the reverse. That is, the ability of LLMs to filter out distractors
significantly outclasses their multi-hop reasoning capacity. Marginalizing
over reasoning hops obfuscates this nuance, hence the reversed trend for
distractors in Column 2. Disentangling these effects is one of our key
contributions.

Finally, for any given $n$ (Columns 1 and 3) or $d$ (Columns 2 and 3), factual
reasoning significantly outperforms anti-factual reasoning. Since we are
carefully controlling for all other factors, this performance gap is directly
indicative of context unfaithfulness: LLMs are inductively biased towards the
factual answer choice. In fact, anti-factual performance quickly degrades to
below random chance with only very moderate scaling of reasoning complexity.
This suggests that as soon as their multi-hop reasoning capacity is exceeded,
LLMs almost exclusively resort to parametric shortcuts.

##  4 Related Work

Paper CF AF Skills Composable Scalable Hops Distractors 2WikiMultiHopQA [49]
2$-$? ? Fakepedia [45] 1$-$2 ? DisentQA [24] ? ? SCOTT [9] ? ? CConS [58] 1 0
CRASS [54] 1 0 ACCORD${}_{\text{CSQA}}$ (Ours) 1$-$5 0$-$4

Table 3: Comparison between ACCORD${}_{\text{CSQA}}$ and related work. CF/AF:
Whether counterfactuals/anti-factuals are present. Skills: Whether reasoning
is based on an explicit set of skills or on an uncontrolled process.
Composable: Whether sub-components (e.g., templates) are composed to generate
complex components. Scalable: Whether the reasoning complexity scales
automatically—or, with at most $O(1)$ additional human effort.
Hops/Distractors: Whether reasoning hops/distractors are measurable, and, if
so, their range. Legend:  : no  : partially  : yes ? : not measurable.

Table 3 compares ACCORD to its most related commonsense reasoning benchmarks
on key features. Below, we expand our discussion of these benchmarks, as well
as of additional related work.

#### Anti-Factual Counterfactuals.

Counterfactuals in prior work can be hypothetical [69, 70, 54, 48] or anti-
factual [23, 18, 24, 58, 45, 28, 48, 32], and can derive from diverse
methodologies, including entity substitution in existing contexts [23, 18, 24,
48, 32], generation using LLMs [71, 45], CoT demonstrations [72, 73, 74, 75],
and other methods [69, 76, 70, 54]. Entity substitution has garnered
considerable attention for its simplicity in creating clear-cut anti-factuals.
Unfortunately, entity substitution is prone to lexical matching bias [24, 45],
which ACCORD avoids with reduplication. In formal reasoning, LLM performance
degrades whenever the surface forms of logic symbols are perturbed relative to
their commonsense semantics [56, 77, 28, 48, 59]. ACCORD extends this analysis
to the informal setting of commonsense reasoning.

#### Controlled Compositional Scaling.

Current LLMs struggle scaling to arbitrarily complex compositional and multi-
hop reasoning tasks [10, 12]. Indeed, this may be a fundamental limitation of
autoregressive architectures [12]. Notwithstanding, existing commonsense tasks
are limited to one- or two-hop reasoning [49, 54, 58, 7, 55, 45] or to an
unknown number of hops and/or distractors [78, 53, 79, 49, 23, 24, 55, 45].
Arbitrarily-scalable compositional reasoning is typical of formal reasoning
tasks [15, 80, 77, 28, 10, 12]. ACCORD introduces these features to informal
commonsense reasoning. Furthermore, ACCORD carefully controls compositionality
via a reasoning skill set, which is analogous to the controlled rule set of
formal reasoning. Most prior commonsense benchmarks either are limited to a
single skill—such as spatial [58] or causal [54, 7, 81], or do not control
skills [24, 55, 45, 9]. To the best of our knowledge, only Ho et al. [49]
examine a rich set of highly-specific commonsense skills, such as
spouse$(a,b)$ $\land$ mother$(b,c)$ $\Rightarrow$ mother_in_law$(a,c)$. This
approach is complementary to ACCORD${}_{\text{CSQA}}$, which employs a rich
set of general commonsense skills.

##  5 Limitations and Future Work

Most datasets and KBs are noisy, including CSQA and ConceptNet [55]. This
limits the quality of ACCORD${}_{\text{CSQA}}$. However, ACCORD in general has
the potential to be of very high quality (e.g., using a small but highly-
curated base dataset and KB), which we leave as future work. In addition,
whereas ConceptNet enables us to control for relation types, it cannot control
for the “degree” of anti-factuality. Consider, for example, that a fish is a
type of mammal intuitively feels “less” anti-factual than a fish is a type of
rock. We have attempted to formalize this intuition using both semantic
distance between template concepts and likelihood functions of grounded
templates [45]. However, grounding a full reasoning path amounts to performing
a random walk in template space. As a result, distant steps along a reasoning
path can end up being more semantically related or more likely than all
intermediate steps, which defeats the purpose of such a control mechanism.

Our goal in this work is to introduce the ACCORD framework and illustrate
baseline performance of LLMs in the simplest setting (zero-shot with a simple
instruction prompt). We would expect performance improvements with careful
demonstrations and prompt engineering. In addition, several prior works
provide valuable detailed insight on template surface forms, such as the
effects of verb and preposition choice [58] or discourse connectives [7].
Since our reasoning skill set is significantly broader, we employed only one
template per skill, while assuming that LLMs are increasingly able to abstract
away template minutiae [82]. Nonetheless, ACCORD${}_{\text{CSQA}}$’s templates
contain stilted language in practice. However, improving the naturalness of
ACCORD${}_{\text{CSQA}}$ is non-trivial. Since its grounding is anti-factual,
LLMs may be unfaithful as template editors (e.g., LLMs generated high-quality
counterfactuals from templates only about one-quarter of the time in Monea et
al. 45). Unfortunately, crowd workers are now widely employing LLMs as
shortcuts [83], leading to the same problem.

##  6 Conclusion

We presented ACCORD, a framework for generating anti-factual commonsense
reasoning benchmarks. ACCORD introduces formal elements to commonsense
reasoning, and thus takes a significant step towards closing the commonsense
measurability gap with respect to formal reasoning. In particular, ACCORD
disentangles commonsense grounding and reasoning abilities in LLMs, while
controlling for both reasoning complexity, reasoning skills, and distractors.
Experiments on our ACCORD${}_{\text{CSQA}}$ benchmark suite, an application of
the ACCORD framework to CSQA, demonstrate that the performance of state-of-
the-art LLMs degrades to random chance with only moderate scaling, leaving
substantial room for improvement. ACCORD is uniquely designed to automatically
scale its difficulty level in tandem with future LLM improvements by
leveraging compositional scalability to generate future benchmarks of
arbitrary reasoning complexity with minimal additional human effort.

## Acknowledgments and Disclosure of Funding

Resources used in preparing this research were provided, in part, by the
Province of Ontario, the Government of Canada through CIFAR, and companies
sponsoring the Vector Institute www.vectorinstitute.ai/#partners. Frank
Rudzicz is supported by a Canada CIFAR Chair in AI. We would like to thank Ian
Berlot-Attwell and Kalyna Kryworuchko for their valued insights on this
research.

## References

  * Wei et al. [2022a] Jason Wei, Yi Tay, Rishi Bommasani, Colin Raffel, Barret Zoph, Sebastian Borgeaud, Dani Yogatama, Maarten Bosma, Denny Zhou, Donald Metzler, Ed H. Chi, Tatsunori Hashimoto, Oriol Vinyals, Percy Liang, Jeff Dean, and William Fedus.  Emergent Abilities of Large Language Models.  _arXiv preprint arXiv:2206.07682_ , 2022a.
  * Wei et al. [2022b] Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H. Chi, Quoc V. Le, and Denny Zhou.  Chain-of-Thought Prompting Elicits Reasoning in Large Language Models.  _Advances in Neural Information Processing Systems_ , 35:24824–24837, 2022b.
  * Kojima et al. [2022] Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa.  Large Language Models Are Zero-Shot Reasoners.  _Advances in neural information processing systems_ , 35:22199–22213, 2022.
  * Huang and Chang [2022] Jie Huang and Kevin Chen-Chuan Chang.  Towards Reasoning in Large Language Models: A Survey.  _arXiv preprint arXiv:2212.10403_ , 2022.
  * Valmeekam et al. [2022] Karthik Valmeekam, Alberto Olmo, Sarath Sreedharan, and Subbarao Kambhampati.  Large Language Models Still Can’t Plan (A Benchmark for LLMs on Planning and Reasoning about Change).  _arXiv preprint arXiv:2206.10498_ , 2022.
  * Bang et al. [2023] Yejin Bang, Samuel Cahyawijaya, Nayeon Lee, Wenliang Dai, Dan Su, Bryan Wilie, Holy Lovenia, Ziwei Ji, Tiezheng Yu, Willy Chung, et al.  A Multitask, Multilingual, Multimodal Evaluation of ChatGPT on Reasoning, Hallucination, and Interactivity.  _arXiv preprint arXiv:2302.04023_ , 2023.
  * Li et al. [2023] Jiaxuan Li, Lang Yu, and Allyson Ettinger.  Counterfactual Reasoning: Testing Language Models’ Understanding of Hypothetical Scenarios.  _arXiv preprint arXiv:2305.16572_ , 2023.
  * Prasad et al. [2023] Archiki Prasad, Swarnadeep Saha, Xiang Zhou, and Mohit Bansal.  ReCEval: Evaluating Reasoning Chains via Correctness and Informativeness.  _arXiv preprint arXiv:2304.10703_ , 2023.
  * Wang et al. [2023] Peifeng Wang, Zhengyang Wang, Zheng Li, Yifan Gao, Bing Yin, and Xiang Ren.  SCOTT: Self-Consistent Chain-of-Thought Distillation.  _arXiv preprint arXiv:2305.01879_ , 2023.
  * Xu et al. [2023a] Fangzhi Xu, Qika Lin, Jiawei Han, Tianzhe Zhao, Jun Liu, and Erik Cambria.  Are Large Language Models Really Good Logical Reasoners? A Comprehensive Evaluation From Deductive, Inductive and Abductive Views.  _arXiv preprint arXiv:2306.09841_ , 2023a.
  * Yang et al. [2023] Zhun Yang, Adam Ishay, and Joohyung Lee.  Coupling Large Language Models with Logic Programming for Robust and General Reasoning from Text.  _arXiv preprint arXiv:2307.07696_ , 2023.
  * Dziri et al. [2024] Nouha Dziri, Ximing Lu, Melanie Sclar, Xiang Lorraine Li, Liwei Jiang, Bill Yuchen Lin, Sean Welleck, Peter West, Chandra Bhagavatula, Ronan Le Bras, et al.  Faith and Fate: Limits of Transformers on Compositionality.  _Advances in Neural Information Processing Systems_ , 36, 2024.
  * Turpin et al. [2024] Miles Turpin, Julian Michael, Ethan Perez, and Samuel Bowman.  Language Models Don’t Always Say What They Think: Unfaithful Explanations in Chain-of-Thought Prompting.  _Advances in Neural Information Processing Systems_ , 36, 2024.
  * Kassner and Schütze [2019] Nora Kassner and Hinrich Schütze.  Negated and Misprimed Probes for Pretrained Language Models: Birds Can Talk, but Cannot Fly.  _arXiv preprint arXiv:1911.03343_ , 2019.
  * Dalvi et al. [2021] Bhavana Dalvi, Peter Jansen, Oyvind Tafjord, Zhengnan Xie, Hannah Smith, Leighanna Pipatanangkura, and Peter Clark.  Explaining Answers with Entailment Trees.  _arXiv preprint arXiv:2104.08661_ , 2021.
  * Pandia and Ettinger [2021] Lalchand Pandia and Allyson Ettinger.  Sorting Through the Noise: Testing Robustness of Information Processing in Pre-Trained Language Models.  _arXiv preprint arXiv:2109.12393_ , 2021.
  * Wang et al. [2021] Boxin Wang, Chejian Xu, Shuohang Wang, Zhe Gan, Yu Cheng, Jianfeng Gao, Ahmed Hassan Awadallah, and Bo Li.  Adversarial GLUE: A Multi-Task Benchmark for Robustness Evaluation of Language Models.  _arXiv preprint arXiv:2111.02840_ , 2021.
  * Li et al. [2022] Daliang Li, Ankit Singh Rawat, Manzil Zaheer, Xin Wang, Michal Lukasik, Andreas Veit, Felix Yu, and Sanjiv Kumar.  Large Language Models with Controllable Working Memory.  _arXiv preprint arXiv:2211.05110_ , 2022.
  * Misra et al. [2022] Kanishka Misra, Julia Taylor Rayz, and Allyson Ettinger.  COMPS: Conceptual Minimal Pair Sentences for Testing Robust Property Knowledge and its Inheritance in Pre-Trained Language Models.  _arXiv preprint arXiv:2210.01963_ , 2022.
  * Shi et al. [2023] Freda Shi, Xinyun Chen, Kanishka Misra, Nathan Scales, David Dohan, Ed H Chi, Nathanael Schärli, and Denny Zhou.  Large Language Models Can Be Easily Distracted by Irrelevant Context.  In _International Conference on Machine Learning_ , pages 31210–31227. PMLR, 2023.
  * Petroni et al. [2019] Fabio Petroni, Tim Rocktäschel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, Alexander H Miller, and Sebastian Riedel.  Language Models as Knowledge Bases?  _arXiv preprint arXiv:1909.01066_ , 2019.
  * Wu et al. [2023a] Dingjun Wu, Jing Zhang, and Xinmei Huang.  Chain of Thought Prompting Elicits Knowledge Augmentation.  _arXiv preprint arXiv:2307.01640_ , 2023a.
  * Longpre et al. [2021] Shayne Longpre, Kartik Perisetla, Anthony Chen, Nikhil Ramesh, Chris DuBois, and Sameer Singh.  Entity-Based Knowledge Conflicts in Question Answering.  _arXiv preprint arXiv:2109.05052_ , 2021.
  * Neeman et al. [2022] Ella Neeman, Roee Aharoni, Or Honovich, Leshem Choshen, Idan Szpektor, and Omri Abend.  DisentQA: Disentangling Parametric and Contextual Knowledge with Counterfactual Question Answering.  _arXiv preprint arXiv:2211.05655_ , 2022.
  * Baek et al. [2023] Jinheon Baek, Alham Fikri Aji, and Amir Saffari.  Knowledge-Augmented Language Model Prompting for Zero-Shot Knowledge Graph Question Answering.  _arXiv preprint arXiv:2306.04136_ , 2023.
  * Cheng et al. [2023] Xin Cheng, Yankai Lin, Xiuying Chen, Dongyan Zhao, and Rui Yan.  Decouple Knowledge from Paramters for Plug-and-Play Language Modeling.  _arXiv preprint arXiv:2305.11564_ , 2023.
  * Ji et al. [2023a] Ziwei Ji, Zihan Liu, Nayeon Lee, Tiezheng Yu, Bryan Wilie, Min Zeng, and Pascale Fung.  RHO: Reducing Hallucination in Open-Domain Dialogues with Knowledge Grounding.  In _Findings of the Association for Computational Linguistics: ACL 2023_ , pages 4504–4522, 2023a.
  * Tang et al. [2023] Xiaojuan Tang, Zilong Zheng, Jiaqi Li, Fanxu Meng, Song-Chun Zhu, Yitao Liang, and Muhan Zhang.  Large Language Models Are In-Context Semantic Reasoners Rather Than Symbolic Reasoners.  _arXiv preprint arXiv:2305.14825_ , 2023.
  * Sun et al. [2023] Bin Sun, Yitong Li, Fei Mi, Fanhu Bie, Yiwei Li, and Kan Li.  Towards Fewer Hallucinations in Knowledge-Grounded Dialogue Generation via Augmentative and Contrastive Knowledge-Dialogue.  In _Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers)_ , pages 1741–1750, 2023.
  * Yu et al. [2023a] Qinan Yu, Jack Merullo, and Ellie Pavlick.  Characterizing Mechanisms for Factual Recall in Language Models.  _arXiv preprint arXiv:2310.15910_ , 2023a.
  * Zheng et al. [2023] Ce Zheng, Lei Li, Qingxiu Dong, Yuxuan Fan, Zhiyong Wu, Jingjing Xu, and Baobao Chang.  Can We Edit Factual Knowledge by In-Context Learning?  _arXiv preprint arXiv:2305.12740_ , 2023.
  * Zhou et al. [2023] Wenxuan Zhou, Sheng Zhang, Hoifung Poon, and Muhao Chen.  Context-Faithful Prompting for Large Language Models.  _arXiv preprint arXiv:2303.11315_ , 2023.
  * Welleck et al. [2019] Sean Welleck, Ilia Kulikov, Stephen Roller, Emily Dinan, Kyunghyun Cho, and Jason Weston.  Neural Text Generation with Unlikelihood Training.  _arXiv preprint arXiv:1908.04319_ , 2019.
  * Gao et al. [2023] Yunfan Gao, Yun Xiong, Xinyu Gao, Kangxiang Jia, Jinliu Pan, Yuxi Bi, Yi Dai, Jiawei Sun, and Haofen Wang.  Retrieval-Augmented Generation for Large Language Models: A Survey.  _arXiv preprint arXiv:2312.10997_ , 2023.
  * Ji et al. [2023b] Ziwei Ji, Nayeon Lee, Rita Frieske, Tiezheng Yu, Dan Su, Yan Xu, Etsuko Ishii, Ye Jin Bang, Andrea Madotto, and Pascale Fung.  Survey of Hallucination in Natural Language Generation.  _ACM Computing Surveys_ , 55(12):1–38, 2023b.
  * Chen et al. [2023] Jiangjie Chen, Wei Shi, Ziquan Fu, Sijie Cheng, Lei Li, and Yanghua Xiao.  Say What You Mean! Large Language Models Speak Too Positively About Negative Commonsense Knowledge.  _arXiv preprint arXiv:2305.05976_ , 2023.
  * Onoe et al. [2023] Yasumasa Onoe, Michael JQ Zhang, Shankar Padmanabhan, Greg Durrett, and Eunsol Choi.  Can LMs Learn New Entities from Descriptions? Challenges in Propagating Injected Knowledge.  _arXiv preprint arXiv:2305.01651_ , 2023.
  * Xu et al. [2023b] Yan Xu, Mahdi Namazifar, Devamanyu Hazarika, Aishwarya Padmakumar, Yang Liu, and Dilek Hakkani-Tür.  KILM: Knowledge Injection into Encoder-Decoder Language Models.  _arXiv preprint arXiv:2302.09170_ , 2023b.
  * Lewis et al. [2020] Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela.  Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks.  _Advances in Neural Information Processing Systems_ , 33:9459–9474, 2020.
  * Borgeaud et al. [2022] Sebastian Borgeaud, Arthur Mensch, Jordan Hoffmann, Trevor Cai, Eliza Rutherford, Katie Millican, George Bm Van Den Driessche, Jean-Baptiste Lespiau, Bogdan Damoc, Aidan Clark, et al.  Improving Language Models by Retrieving from Trillions of Tokens.  In _International conference on machine learning_ , pages 2206–2240. PMLR, 2022.
  * Trivedi et al. [2022] Harsh Trivedi, Niranjan Balasubramanian, Tushar Khot, and Ashish Sabharwal.  Interleaving Retrieval with Chain-of-Thought Reasoning for Knowledge-Intensive Multi-Step Questions.  _arXiv preprint arXiv:2212.10509_ , 2022.
  * Mialon et al. [2023] Grégoire Mialon, Roberto Dessì, Maria Lomeli, Christoforos Nalmpantis, Ram Pasunuru, Roberta Raileanu, Baptiste Rozière, Timo Schick, Jane Dwivedi-Yu, Asli Celikyilmaz, Edouard Grave, Yann LeCun, and Thomas Scialom.  Augmented Language Models: A Survey.  _arXiv preprint arXiv:2302.07842_ , 2023.
  * Arodi et al. [2022] Akshatha Arodi, Martin Pömsl, Kaheer Suleman, Adam Trischler, Alexandra Olteanu, and Jackie Chi Kit Cheung.  The KITMUS Test: Evaluating Knowledge Integration from Multiple Sources in Natural Language Understanding Systems.  _arXiv preprint arXiv:2212.08192_ , 2022.
  * Huang et al. [2023] Kung-Hsiang Huang, Hou Pong Chan, and Heng Ji.  Zero-Shot Faithful Factual Error Correction.  _arXiv preprint arXiv:2305.07982_ , 2023.
  * Monea et al. [2023] Giovanni Monea, Maxime Peyrard, Martin Josifoski, Vishrav Chaudhary, Jason Eisner, Emre Kıcıman, Hamid Palangi, Barun Patra, and Robert West.  A Glitch in the Matrix? Locating and Detecting Language Model Grounding with Fakepedia.  _arXiv preprint arXiv:2312.02073_ , 2023.
  * McCoy et al. [2019] R Thomas McCoy, Ellie Pavlick, and Tal Linzen.  Right for the Wrong Reasons: Diagnosing Syntactic Heuristics in Natural Language Inference.  _arXiv preprint arXiv:1902.01007_ , 2019.
  * Kıcıman et al. [2023] Emre Kıcıman, Robert Ness, Amit Sharma, and Chenhao Tan.  Causal Reasoning and Large Language Models: Opening a New Frontier for Causality.  _arXiv preprint arXiv:2305.00050_ , 2023.
  * Wu et al. [2023b] Zhaofeng Wu, Linlu Qiu, Alexis Ross, Ekin Akyürek, Boyuan Chen, Bailin Wang, Najoung Kim, Jacob Andreas, and Yoon Kim.  Reasoning or Reciting? Exploring the Capabilities and Limitations of Language Models Through Counterfactual Tasks.  _arXiv preprint arXiv:2307.02477_ , 2023b.
  * Ho et al. [2020] Xanh Ho, Anh-Khoa Duong Nguyen, Saku Sugawara, and Akiko Aizawa.  Constructing a Multi-Hop QA Dataset for Comprehensive Evaluation of Reasoning Steps.  _arXiv preprint arXiv:2011.01060_ , 2020.
  * Feng et al. [2022] Yu Feng, Ben Zhou, Haoyu Wang, Helen Jin, and Dan Roth.  Generic Temporal Reasoning with Differential Analysis and Explanation.  _arXiv preprint arXiv:2212.10467_ , 2022.
  * Guo et al. [2022] Wangzhen Guo, Qinkang Gong, and Hanjiang Lai.  Counterfactual Multihop QA: A Cause-Effect Approach for Reducing Disconnected Reasoning.  _arXiv preprint arXiv:2210.07138_ , 2022.
  * Yuan et al. [2023] Siyu Yuan, Deqing Yang, Jinxi Liu, Shuyu Tian, Jiaqing Liang, Yanghua Xiao, and Rui Xie.  Causality-Aware Concept Extraction Based on Knowledge-Guided Prompting.  _arXiv preprint arXiv:2305.01876_ , 2023.
  * Kaushik et al. [2019] Divyansh Kaushik, Eduard Hovy, and Zachary C Lipton.  Learning the Difference that Makes a Difference with Counterfactually-Augmented Data.  _arXiv preprint arXiv:1909.12434_ , 2019.
  * Frohberg and Binder [2021] Jörg Frohberg and Frank Binder.  CRASS: A Novel Data Set and Benchmark to Test Counterfactual Reasoning of Large Language Models.  _arXiv preprint arXiv:2112.11941_ , 2021.
  * Davis [2023] Ernest Davis.  Benchmarks for Automated Commonsense Reasoning: A Survey.  _arXiv preprint arXiv:2302.04752_ , 2023.
  * Dasgupta et al. [2022] Ishita Dasgupta, Andrew K Lampinen, Stephanie CY Chan, Antonia Creswell, Dharshan Kumaran, James L McClelland, and Felix Hill.  Language Models Show Human-Like Content Effects on Reasoning.  _arXiv preprint arXiv:2207.07051_ , 2022.
  * Chan et al. [2023] Robin Chan, Afra Amini, and Mennatallah El-Assady.  Which Spurious Correlations Impact Reasoning in NLI Models? A Visual Interactive Diagnosis through Data-Constrained Counterfactuals.  _arXiv preprint arXiv:2306.12146_ , 2023.
  * Kondo et al. [2023] Kazushi Kondo, Saku Sugawara, and Akiko Aizawa.  Probing Physical Reasoning with Counter-Commonsense Context.  _arXiv preprint arXiv:2306.02258_ , 2023.
  * Yu et al. [2023b] Wenhao Yu, Meng Jiang, Peter Clark, and Ashish Sabharwal.  IfQA: A Dataset for Open-Domain Question Answering under Counterfactual Presuppositions.  _arXiv preprint arXiv:2305.14010_ , 2023b.
  * Qiao et al. [2022] Shuofei Qiao, Yixin Ou, Ningyu Zhang, Xiang Chen, Yunzhi Yao, Shumin Deng, Chuanqi Tan, Fei Huang, and Huajun Chen.  Reasoning with Language Model Prompting: A Survey.  _arXiv preprint arXiv:2212.09597_ , 2022.
  * Talmor et al. [2018] Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant.  CommonsenseQA: A Question Answering Challenge Targeting Commonsense Knowledge.  _arXiv preprint arXiv:1811.00937_ , 2018.
  * Speer et al. [2017] Robyn Speer, Joshua Chin, and Catherine Havasi.  ConceptNet 5.5: An Open Multilingual Graph of General Knowledge.  In _Proceedings of the AAAI conference on artificial intelligence_ , volume 31, 2017.
  * Talmor et al. [2022] Alon Talmor, Ori Yoran, Ronan Le Bras, Chandra Bhagavatula, Yoav Goldberg, Yejin Choi, and Jonathan Berant.  CommonsenseQA 2.0: Exposing the Limits of AI Through Gamification.  _arXiv preprint arXiv:2201.05320_ , 2022.
  * Mihaylov et al. [2018] Todor Mihaylov, Peter Clark, Tushar Khot, and Ashish Sabharwal.  Can a Suit of Armor Conduct Electricity? A New Dataset for Open Book Question Answering.  _arXiv preprint arXiv:1809.02789_ , 2018.
  * Geva et al. [2021] Mor Geva, Daniel Khashabi, Elad Segal, Tushar Khot, Dan Roth, and Jonathan Berant.  Did Aristotle Use a Laptop? A Question Answering Benchmark with Implicit Reasoning Strategies.  _Transactions of the Association for Computational Linguistics_ , 9:346–361, 2021.
  * OpenAI [2024] OpenAI.  Gpt-4o, 2024.  URL https://openai.com/index/hello-gpt-4o.  Accessed: 2024-05-28.
  * AI@Meta [2024] AI@Meta.  Llama 3 Model Card, 2024.  URL https://github.com/meta-llama/llama3/blob/main/MODEL_CARD.md.  Accessed: 2024-05-28.
  * Team [2024] The Mistral AI Team.  Mixtral 8x22B Model Card, 2024.  URL https://huggingface.co/mistralai/Mixtral-8x22B-Instruct-v0.1.  Accessed: 2024-05-28.
  * Qin et al. [2019] Lianhui Qin, Antoine Bosselut, Ari Holtzman, Chandra Bhagavatula, Elizabeth Clark, and Yejin Choi.  Counterfactual Story Reasoning and Generation.  _arXiv preprint arXiv:1909.04076_ , 2019.
  * Qin et al. [2020] Lianhui Qin, Vered Shwartz, Peter West, Chandra Bhagavatula, Jena Hwang, Ronan Le Bras, Antoine Bosselut, and Yejin Choi.  Back to the Future: Unsupervised Backprop-Based Decoding for Counterfactual and Abductive Commonsense Reasoning.  _arXiv preprint arXiv:2010.05906_ , 2020.
  * Fu et al. [2023] Deqing Fu, Ameya Godbole, and Robin Jia.  SCENE: Self-Labeled Counterfactuals for Extrapolating to Negative Examples.  _arXiv preprint arXiv:2305.07984_ , 2023.
  * Madaan and Yazdanbakhsh [2022] Aman Madaan and Amir Yazdanbakhsh.  Text and Patterns: For Effective Chain of Thought, it Takes two to Tango.  _arXiv preprint arXiv:2209.07686_ , 2022.
  * Wang et al. [2022] Boshi Wang, Sewon Min, Xiang Deng, Jiaming Shen, You Wu, Luke Zettlemoyer, and Huan Sun.  Towards Understanding Chain-of-Thought Prompting: An Empirical Study of What Matters.  _arXiv preprint arXiv:2212.10001_ , 2022.
  * Ye et al. [2022] Xi Ye, Srinivasan Iyer, Asli Celikyilmaz, Ves Stoyanov, Greg Durrett, and Ramakanth Pasunuru.  Complementary Explanations for Effective In-Context Learning.  _arXiv preprint arXiv:2211.13892_ , 2022.
  * Lanham et al. [2023] Tamera Lanham, Anna Chen, Ansh Radhakrishnan, Benoit Steiner, Carson Denison, Danny Hernandez, Dustin Li, Esin Durmus, Evan Hubinger, Jackson Kernion, et al.  Measuring Faithfulness in Chain-of-Thought Reasoning.  _arXiv preprint arXiv:2307.13702_ , 2023.
  * Kaushik et al. [2020] Divyansh Kaushik, Amrith Setlur, Eduard Hovy, and Zachary C Lipton.  Explaining the Efficacy of Counterfactually Augmented Data.  _arXiv preprint arXiv:2010.02114_ , 2020.
  * Han et al. [2022] Simeng Han, Hailey Schoelkopf, Yilun Zhao, Zhenting Qi, Martin Riddell, Luke Benson, Lucy Sun, Ekaterina Zubova, Yujie Qiao, Matthew Burtell, et al.  FOLIO: Natural Language Reasoning with First-Order Logic.  _arXiv preprint arXiv:2209.00840_ , 2022.
  * Chen and Durrett [2019] Jifan Chen and Greg Durrett.  Understanding Dataset Design Choices for Multi-Hop Reasoning.  _arXiv preprint arXiv:1904.12106_ , 2019.
  * Min et al. [2019] Sewon Min, Eric Wallace, Sameer Singh, Matt Gardner, Hannaneh Hajishirzi, and Luke Zettlemoyer.  Compositional Questions Do not Necessitate Multi-Hop Reasoning.  _arXiv preprint arXiv:1906.02900_ , 2019.
  * Tian et al. [2021] Jidong Tian, Yitian Li, Wenqing Chen, Liqiang Xiao, Hao He, and Yaohui Jin.  Diagnosing the First-Order Logical Reasoning Ability Through LogicNLI.  In _Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing_ , pages 3738–3747, 2021.
  * Jin et al. [2024] Zhijing Jin, Yuen Chen, Felix Leeb, Luigi Gresele, Ojasv Kamal, Zhiheng Lyu, Kevin Blin, Fernando Gonzalez Adauto, Max Kleiman-Weiner, Mrinmaya Sachan, et al.  CLadder: A Benchmark to Assess Causal Reasoning Capabilities of Language Models.  _Advances in Neural Information Processing Systems_ , 36, 2024.
  * Si et al. [2023] Chenglei Si, Dan Friedman, Nitish Joshi, Shi Feng, Danqi Chen, and He He.  Measuring Inductive Biases of In-Context Learning with Underspecified Demonstrations.  _arXiv preprint arXiv:2305.13299_ , 2023.
  * Veselovsky et al. [2023] Veniamin Veselovsky, Manoel Horta Ribeiro, and Robert West.  Artificial Artificial Artificial Intelligence: Crowd Workers Widely Use Large Language Models for Text Production Tasks.  _arXiv preprint arXiv:2306.07899_ , 2023.

## Checklist

  1. 1.

For all authors…

    1. (a)

Do the main claims made in the abstract and introduction accurately reflect
the paper’s contributions and scope? [Yes]

    2. (b)

Did you describe the limitations of your work? [Yes]

    3. (c)

Did you discuss any potential negative societal impacts of your work? [Yes]
See Supplemental Material.

    4. (d)

Have you read the ethics review guidelines and ensured that your paper
conforms to them? [Yes]

  2. 2.

If you are including theoretical results…

    1. (a)

Did you state the full set of assumptions of all theoretical results? [N/A]

    2. (b)

Did you include complete proofs of all theoretical results? [N/A]

  3. 3.

If you ran experiments (e.g. for benchmarks)…

    1. (a)

Did you include the code, data, and instructions needed to reproduce the main
experimental results (either in the supplemental material or as a URL)? [Yes]
See Supplemental Material.

    2. (b)

Did you specify all the training details (e.g., data splits, hyperparameters,
how they were chosen)? [Yes] See Supplemental Material.

    3. (c)

Did you report error bars (e.g., with respect to the random seed after running
experiments multiple times)? [Yes] Wald standard error bars are with respect
to the 93 pairings, not reruns based on random seeds.

    4. (d)

Did you include the total amount of compute and the type of resources used
(e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See
Supplemental Material.

  4. 4.

If you are using existing assets (e.g., code, data, models) or
curating/releasing new assets…

    1. (a)

If your work uses existing assets, did you cite the creators? [Yes]

    2. (b)

Did you mention the license of the assets? [Yes]

    3. (c)

Did you include any new assets either in the supplemental material or as a
URL? [Yes]

    4. (d)

Did you discuss whether and how consent was obtained from people whose data
you’re using/curating? [Yes] See Supplemental Material.

    5. (e)

Did you discuss whether the data you are using/curating contains personally
identifiable information or offensive content? [Yes] See Supplemental
Material.

  5. 5.

If you used crowdsourcing or conducted research with human subjects…

    1. (a)

Did you include the full text of instructions given to participants and
screenshots, if applicable? [N/A]

    2. (b)

Did you describe any potential participant risks, with links to Institutional
Review Board (IRB) approvals, if applicable? [N/A]

    3. (c)

Did you include the estimated hourly wage paid to participants and the total
amount spent on participant compensation? [N/A]