# Decomposing Natural Logic Inferences in Neural NLI

Julia Rozanova$~{}^{\dagger}$, Deborah Ferreira†, Mokanarangan Thayaparan†,
Marco Valentino†, André Freitas†‡
Department of Computer Science, University of Manchester, United Kingdom†
Idiap Research Institute, Switzerland‡
{firstname.surname} @manchester.ac.uk

###### Abstract

In the interest of interpreting neural NLI models and their reasoning
strategies, we carry out a systematic probing study which investigates whether
these models capture the crucial semantic features central to natural logic:
_monotonicity_ and _concept inclusion_. Correctly identifying valid inferences
in _downward-monotone contexts_ is a known stumbling block for NLI
performance, subsuming linguistic phenomena such as negation scope and
generalized quantifiers. To understand this difficulty, we emphasize
monotonicity as a property of a _context_ and examine the extent to which
models capture monotonicity information in the contextual embeddings which are
intermediate to their decision making process. Drawing on the recent
advancement of the probing paradigm, we compare the presence of monotonicity
features across various models. We find that monotonicity information is
notably weak in the representations of popular NLI models which achieve high
scores on benchmarks, and observe that previous improvements to these models
based on fine-tuning strategies have introduced stronger monotonicity features
together with their improved performance on challenge sets.

##  1 Introduction

Large, black box neural models which achieve high scores on benchmark datasets
designed for testing _natural language understanding_ are the subject of much
scrutiny and investigation.

It is often investigated whether models are able to capture specific semantic
phenomena which mimic human reasoning and/or logical formalism, as there is
evidence that they sometimes exploit simple heuristics and dataset artifacts
instead McCoy et al. (2019); Herlihy and Rudinger (2021).

In this work, we consider the rigorous setting of _natural logic_ MacCartney
and Manning (2007). This is a highly systematic reasoning principle relying on
only two abstract features, each of which is in itself linguistically complex:
_monotonicity_ and _concept inclusion relations_. It underlies the majority of
symbolic/rule-based and hybrid approaches to NLI and is an important baseline
reasoning phenomenon to look for in a robust and principled NLI model.

Downward monotone operators such as negations and generalized quantifiers
result in the kinds of natural logic inferences which are often known to stump
neural NLI models that demonstrate high performance on large benchmark sets
such as MNLI Williams et al. (2018).

By contrast, in this work we present a structural study: investigating to what
extent the features relevant for identifying natural logic inferences,
especially context monotonicty itself, are captured in the model’s internal
representations.

In this work, we carry out a systematic probing study to estimate and compare
the extent to which the abstract features at the heart of monotonicity
reasoning – i.e., context monotonicity and concept inclusion relations – are
present in various NLI models’ representations.

Our contributions are may be summarized as follows:

  1. 1.

We perform a structural investigation as to whether the behaviour of _natural
logic_ formalisms are mimicked within popular transformer-based NLI models.

  2. 2.

For this purpose, we present a joint NLI and semantic probing dataset format
(and dataset) which we call NLI-$XY$: it is a unique probing dataset in that
the probed features relate to the NLI task output in a very systematic way.

  3. 3.

We employ thorough probing techniques to determine whether the abstract
semantic features of _context monotonicity_ and _concept inclusion relations_
are captured in the models’ internal representations.

  4. 4.

We observe that some well-known NLI models demonstrate a systematic failure to
model context monotonicity, a behaviour we observe to correspond to poor
performance on natural logic reasoning in downward-monotone contexts. However,
we show that the existing HELP dataset improves this behaviour.

  5. 5.

We support the observations in the probing study with several _qualitative
analyses_ , including decomposed error-breakdowns on the NLI-XY dataset,
representation visualizations, and evaluations on existing challenge sets.

##  2 Related Work

Natural logic dates back to the formalisms of Sanchez (1991), but has been
received more recent treatments and reformulations in MacCartney and Manning
(2007); Hu and Moss (2018). Symbolic and hybrid neural/symbolic
implementations of the natural logic paradigm have been explored in Chen et
al. (2021); Kalouli et al. (2020); Abzianidze (2017); Hu et al. (2020).

The shortcomings of natural logic handling in various neural NLI models have
been shown with several _behavioural_ studies, where NLI challenge sets
exhibiting examples of downward monotone reasoning are used to evaluate
performance of models with respect to these reasoning patterns Richardson et
al. (2019); Yanaka et al. (2019b, a); Goodwin et al. (2020); Geiger et al.
(2020).

In an attempt to better identify features that neural models manage or fail to
capture, researchers have employed _probing_ strategies: namely, the
_diagnostic classification_ Alain and Bengio (2018) of auxiliary feature
labels from internal model representations. Most probing studies in natural
language processing focus on the _syntactic_ features captured in transformer-
based language models Hewitt and Manning (2019), but calls have been made for
more sophisticated probing tasks which rely more on contextual information
Pimentel et al. (2020).

In the realm of semantics, probing studies have focused more on _lexical_
semantics Vulić et al. (2020): word pair relations are central to monotonicity
reasoning, and thus form part of our probing study as well, but the novelty of
our work is the task of classifying context monotonicity from contextual word
embeddings. Due to its context-sensitive nature, it cannot be learnt by
“memorizing" the labels of specific words in the training data, a key
shortcoming in probing studies which focus on tasks such as POS tagging and
word-pair relation classification, which have much less dependency on context.

##  3 Problem Formulation

###  3.1 Decomposing Natural Logic

Natural logic inferences (as formalized in Sanchez (1991); MacCartney and
Manning (2007)) are usually described with respect to _substitution_
operations. Certain word substitutions result in either forward or reverse
entailment, while others result in neither. This is the basis for a calculus
of determining entailment from substitution sequences MacCartney and Manning
(2007); Hu et al. (2020); Hu and Moss (2018).

Broadly speaking, we wish to determine whether well-known transformer-based
NLI models mimic the reasoning strategies of natural logic. However, as neural
NLI models are black box classifiers that only see a premise/hypothesis
sentence pair as its input, it is not immediate how to compare its process to
a rule-based system.

To this end, we consider a formulation of natural logic which describes its
rules in terms of concept pair relations and _context monotonicity_ (similar
to Rozanova et al. (2021)).

Consider the following example of a single step natural logic inference, which
we will decompose into semantic components relevant to its entailment label:

|  | NLI Label
---|---|---
Premise | I did not eat any fruit for breakfast. | Entailment
Hypothesis | I did not eat any raspberries for breakfast.

The hyponym/hypernym pair $($raspberries, fruit$)$ exemplifies a more general
relation which we will refer to as the _concept inclusion_ 111In MacCartney
and Manning (2007), this is treated as a “generalized entailment” relation
which is defined on word/phrase pairs and extends to full sentences pairs
using natural logic rules. relation $\sqsubset$, (and dually, _reverse concept
inclusion_ $\sqsupset$) in reference to the semantic interpretation of
predicates related with subset inclusion, as in:

$\\{x\mid\text{raspberry}(x)\\}\subset\\{x\mid\text{fruit}(x)\\}.$

In the above example, they occur in a shared context, namely the sentence
template

> “I did not eat any  for breakfast".

Such a context may be treated as a _function_ $f$

$f:(\mathcal{X},\sqsubseteq)\to(\mathcal{S},\Rightarrow)$

between a set of concepts $\mathcal{X}$ (ordered by the concept inclusion
relation) and the set $\mathcal{S}$ of full sentences ordered by entailment.
We say that $f$ is _upward monotone_ $(\uparrow)$ if it is order _preserving_
, i.e.

$\forall_{X,Y}(X\sqsubseteq Y~{}\text{implies}~{}f(X)\Rightarrow f(Y))$

and that $f$ is _downward monotone_ $(\downarrow)$ if it is order _reversing_
, i.e.

$\forall_{X,Y}(X\sqsupseteq Y~{}\text{implies}~{}f(X)\Rightarrow f(Y)).$

Given a natural language context $f$, any pair of grammatically valid
insertions $(X,Y)$ (e.g. ("raspberries", "fruit")) yields a sentence pair
$f(X),f(Y)$. Treating $f(X)$ as a _premise_ sentence and $f(Y)$ as a
_hypothesis_ sentence, a trained neural NLI model can provide a classification
of whether $f(X)$ entails $f(Y).$

In summary, these two abstract linguistic features, _context montonicity_ and
_concept inclusion relation_ , jointly determine the final gold entailment
label of this type of NLI example.

Context Monotonicity mon($f$) $\in\\{\uparrow,\downarrow\\}$ Concept Relation
$rel(\mathbf{X},\mathbf{Y})\in\\{=,\sqsubseteq,\sqsupseteq\\}$ Entailment
Label for $(f(\mathbf{X}),f(\mathbf{Y}))$

###  3.2 NLI-$XY$ Dataset Format

We follow this formalism as the basis for a _dataset format_ , which we refer
to as NLI-$XY$. This is the first probing dataset format (and consequently,
dataset) in NLP where the auxiliary labels for intermediate semantic features
influence the final task label in a rigid and determinate (yet simple) way,
with these features being themselves linguistically complex. As such, it is as
such a "decomposed" natural logic dataset format, where the positive
entailment labels are further enriched with labels for the monotonicity and
relational properties which gave rise to them. This allows for informative
qualitative and structural analyses into natural logic handling strategies in
neural NLI models.

|  |  |  Auxilliary Label
---|---|---|---
Context | $f$ |  I did not eat any  for breakfast. |  $\downarrow$ (downward monotone)
Insertion Pair | (X,Y) |  (fruit, raspberries) |  $\sqsupset$ (reverse concept inclusion)
|  |  |  NLI Label
Premise | $f(X)$ |  I did not eat any fruit for breakfast. |  Entailment
Hypothesis | $f(Y)$ |  I did not eat any raspberries for breakfast.

Table 1: A typical NLI-XY example with labels for context monotonicity,
lexical relation and the final entailment label.

The NLI-$XY$ dataset format is comprised of the following:

  1. 1.

A set of _contexts_ $f$ with a blank position indicated with an ‘$x$’, marked
for the context monotonicity label.

  2. 2.

A set of _insertion pairs_ $(X,Y)$, which are either words or phrases, labeled
with the concept inclusion relation.

  3. 3.

A derived set of premise and hypothesis pairs $(f(X),f(Y)$ made up of
permutations of $(X,Y)$ insertion pairs through contexts $f$, controlled for
grammaticality as far as possible.

The premise/hypothesis pairs may thus be used as input to any NLI model, while
the context monotonicity and insertion relation information can be used as the
targets of an auxiliary probing task on top of the model’s representations.

##  4 NLI-XY Dataset Construction

We make our NLI-XY dataset and all the experimental code used in this work is
publically available 222Anonymized github link.. We constructed the NLI-$XY$
dataset used here as follows:

##### Context Extraction

We extract context examples from two NLI datasets which were designed for the
behavioural analysis of NLI model performance on monotonicity reasoning. In
particular, we use the manually curated evaluation set MED Yanaka et al.
(2019a) and the automatically generated HELP training set Yanaka et al.
(2019b). By design, as they are collections of NLI examples exhibiting
monotonicity reasoning, these datasets mostly follow our required
$(f(X),f(Y))$ structure, and are labeled as instances of upward or downward
monotonicity reasoning(although the contexts are not explicitly identified).

We extract the common context $f$ from these examples after manually removing
a few which do not follow this structure (differing, for example, in pronoun
number agreement or prepositional phrases). We choose to treat determiners and
quantifiers as part of the context, as these are the kinds of closed-class
linguistic operators whose monotonicity profiles we are interested in. To
ensure grammatically valid insertions, we manually identify whether each
context as suitable either for a singular noun, mass noun or plural noun in
the blank/$x$ position.

##### Insertion Pairs

Our $(X,Y)$ insertion phrase pairs come from two sources: Firstly, the labeled
word pairs from the MoNLI dataset Geiger et al. (2020), which features only
single-word noun phrases. Secondly, we include an additional hand-curated
dataset which has a small number of _phrase-pair_ examples, which includes
intersective modifiers (e.g. (brown sugar, sugar)) and prepositional phrases
(e.g. (sentence, sentence about oranges)). Several of these examples were
drawn from the MED dataset. Each word in the pair is labelled as a singular,
plural or mass noun, so that they may be permuted through the contexts in a
reasonably grammatical way.

##### Premise/Hypothesis Pairs

Premise/Hypothesis pairs are constructed by permuting insertion pairs through
the set of contexts within the grammatical constraints. Note that the data is
split into train, dev and test partitions _before_ this permutation occurs, so
that there are no shared contexts or insertion pairs between the different
data partitions, in an attempt to avoid overlap issues such as those discussed
in Lewis et al. (2021)

|  | Context Monotonicity
---|---|---
Partition | (X,Y) Relation | Up $\uparrow$ | Down $\downarrow$ | Total
train | $\sqsubseteq$ | 671 | 543 | 1214
| $\sqsupset$ | 671 | 543 | 1214
| None | 244 | 222 | 466
| Total | 1586 | 1308 | 2894
dev | $\sqsubseteq$ | 598 | 389 | 987
| $\sqsupset$ | 598 | 389 | 987
| None | 220 | 242 | 462
| Total | 1416 | 1020 | 2436
test | $\sqsubseteq$ | 1103 | 1066 | 2169
| $\sqsupset$ | 1103 | 1066 | 2169
| None | 502 | 516 | 1018
| Total | 2708 | 2648 | 5356

Table 2: Dataset statistics for the NLI-XY dataset. We employ an aggressive
$30,20,50$ train-dev-test split for a more impactful probing result.

##  5 Experimental Setup

Our experiments are designed to investigate the following questions: Firstly,
to what extent do different NLI models differ in their encoding of context
monotonicity and lexical relational knowledge? Secondly, if a model
successfully captures these features, to what extent do they correspond with
the model’s predicted entailment label? We investigate these questions with a
detailed probing study and a supporting qualitative analysis, using decomposed
error break-downs and representation visualization.

###  5.1 Models and Representations

We consider a selection of neural NLI models based on transformer language
models (such as BERT Devlin et al. (2019), RoBERTa Liu et al. (2019) and BART
Lewis et al. (2020)) which are fine-tuned on one of two benchmark training
sets: either SNLI Bowman et al. (2015) or MNLI Williams et al. (2018). Of
particular interest, however, is the case where these models are trained on an
additional dataset (the HELP dataset from Yanaka et al. (2019b)) which was
designed for improving the overall balance of upward and downward monotone
contexts in NLI training data. We use our own random $50-30-20$ train-dev-test
split of the HELP dataset (ensuring unique contexts in every split), so that
there is no overlap of contexts between the fine-tuning data and the few HELP-
test examples we used as part of our NLI-XY dataset333We use the
_transformers_ library Wolf et al. (2020) and their available pretrained
models for this work..

Figure 1: Probing results for all examined models.

###  5.2 Probing

The NLI-XY dataset is equipped with two auxiliary feature labels which are the
targets of the probing task: context monotonicity and the relation of the
$(X,Y)$ phrase pair (referred to henceforth as either concept inclusion
relation or lexical relation).

####  5.2.1 Models and Representations

For each auxiliary task, we use simple linear model architectures as the
probes. We train 50 probes of varying complexities using the _probe-ably_
framework Ferreira et al. (2021). The target of the probing study is the
classification token of the final layer of each model, as is used for the
final NLI classification decision.

|  |  |  Feature Probing |  | NLI Monotonicity Challenge Sets
---|---|---|---|---|---
NLI Models |  | Fine-Tuning
---
Data
|  | Context
---
Monotonicity
(%*)
| XY Insertion
---
Relation
(%*)
|  | HELP-Test
---
(%)
| MED
---
(%)
| NLI-XY
---
(%)
roberta-large-mnli | - |  | 71.0 | 84.0 |  | 36.69 | 46.10 | 59.01
roberta-large-mnli | HELP |  | 82.0 | 78.0 |  | 97.63 | 78.22 | 80.68
roberta-large-mnli |  | HELP,
---
HELP-Contexts
| 84.0 | 76.0 |  | 87.17 | 76.44 | 79.29
facebook/bart-large-mnli |  |  | 76.0 | 48.0 |  | 43.61 | 46.54 | 60.59
facebook/bart-large-mnli | HELP |  | 76.0 | 56.0 |  | 88.99 | 77.16 | 79.3417
bert-base-uncased-snli |  |  | 77.0 | 50.0 |  | 63.55 | 0.4938 | 49.09
bert-base-uncased-snli | HELP |  | 77.0 | 51.0 |  | 66.80 | 0.4613 | 44.79

Table 3: Summary NLI challenge test set and probing results for all considered
models. ∗Probing results are summarized with the _accuracy at max
selectivity_.

####  5.2.2 Probe Complexity Control

The complexities are represented and controlled as follows: For linear models
$\hat{y}=W\mathbf{x}+\mathbf{b}$, we follow pimentel-etal-2020-pareto in using
the nuclear norm

$||\mathbf{W}||_{*}=\sum_{i=1}^{min(|\mathcal{T}|,d)}\sigma_{i}(\mathbf{W}).$

of the matrix $W$ as the approximate measure of complexity. In cases where the
auxiliary task has a relatively large number of classes, the rank has been
used as the proxy measure of model complexity Hewitt and Manning (2019). As
the nuclear norm is a convex approximation of the _rank_ of the transformation
matrix, it is used in Pimentel et al. (2020), where this allows for a larger
number of informative values.

####  5.2.3 Metrics and Control Tasks

##### Accuracy and Selectivity

Naively, a strong accuracy on the probing test set may be understood to
indicate strong presence of the target features within the learned
representations, but there has been much discussion about whether this
evidence is compelling on its own. In fact, certain probing experiments have
found the same accuracy scores for random representations Zhang and Bowman
(2018), indicating that high accuracy scores are meaningless in isolation.
Hewitt and Liang (2019) describe this as a dichotomy between the
representation’s encoding of the target features and the probe’s capacity for
_memorization_ , and propose the use of the _selectivity_ measure to always
place the probe accuracy in the context of a controlled probing task with
shuffled labels on the same vector representations. For each fully trained
probe, we report both the test accuracy and the _selectivity_ measure:
tracking the selectivity ensures that we are not using a probe that is complex
enough to be _overly expressive_ to the point of having the capacity to
overfit the randomised control training set.

##### Control Task

The _selectivity_ score is calculated with respect to a _control task_. At its
core, this is just a balanced random relabelling of the auxiliary data, but
Hewitt and Liang (2019) advocate for more targeted control tasks with respect
to the features in question and a hypothesis about the model’s possible
capacity for _memorization_. For example, in their control task for POS
tagging, they assign the same label to each instance of a word’s surface form
(“word type") to account for possible lexical memorization. By construction,
our context monotonicity classification task is much more context-dependant
and balanced: a given $X$ insertion will occur about as often in upward and
downward monotone contexts, making it harder for a probe to exploit
meaningless heuristics, such as associating a given word with a context
monotonicity label. For the lexical relation classification control task, we
assign a shared random label for all identical insertion pairs, regardless of
context.

###  5.3 NLI Challenge Set Evaluations

As well as the NLI-$XY$ dataset (which can function as an ordinary NLI
evaluation set), for completeness we report NLI task evaluation scores on the
full MED dataset Yanaka et al. (2019a), which was designed as a thorough
stress-test of monotonicity reasoning performance. Furthermore, we report
scores on the HELP-test set (from the dataset split in Rozanova et al.
(2021)): this data partition was not used in the fine-tuning of models on
HELP, but we include the test scores here for insight.

(a)

(b)

(c)

(d)

Figure 2: Decomposed error heat maps for portions of the NLI-XY dataset
corresponding to the indicated context monotonicity and insertion relations
(blank positions are present as only grammatical insertions were included in
the dataset.)

###  5.4 Qualitative Analyses

To complement the probing and NLI results, we make two additional comparisons
that may qualify the observations.

##### Decomposed Error Analysis

The compositional structure and auxiliary labels in the NLI-XY dataset allow
for extensive qualitative analysis. Firstly, we construct decomposed error
analysis heatmaps which indicate whether a given premise-hypothesis data point
$f(X),f(Y)$ is correctly classified by an entailment model. For brevity (and
because this is representative of our observations), we include only the error
breakdowns for the two sublasses of the positive entailment label: where the
context monotonicity is upward and lexical relation is forward incusion, and
where the context monotonicity is downward and the lexical relation is reverse
inclusion.

##### Representation Visualization

We store the classification token ([CLS]) of the model’s last hidden layer and
project it into a lower-dimensional space using the _umap_ library McInnes et
al. (2018) with the default configuration. To qualify the context monotonicity
probing results, we label the points according to the _gold_ context
monotonicity / concept relation labels.

##  6 Results and Discussion

###  6.1 Probing Results

The results for the linear probing experiments for both the _context
monotonicity classification_ task and the _lexical relation_ classification
task may be found in figure 1. The results of the control tasks are taken into
account as part of the selectivity measure, which is represented on the right
hand plot for each experiment. It is particularly notable that large datasets
trained only on the MNLI dataset have inferior performance on context
monotonicity classification. This corresponds with the further qualitative
studies, suggesting that even in some of the most successful transformer-based
NLI models, _there is a poor “understanding" of the logical regularities of
contexts and how these are altered with downward monotone operators._

###  6.2 Comparison to Challenge Set Performance

Evaluation on the challenge test sets is relatively consistent with
monotonicity probing performance, in the sense that there is a correspondence
between poor/successful modeling of monotonicity features and poor/successful
performance on a targeted natural logic test set. As these challenge sets are
focused on testing monotonicity reasoning, this is a result which strongly
bolsters the suggestion that explicit representation of the context
monotonicity feature is crucial, especially for examples involving negation
and other downward monotone operators. Furthermore, we generally confirm
previous results that additional fine-tuning on the HELP data set has been
helpful for these specialized test sets, and add to this that it similarly
improves the explicit extractability of relevant context montonicity features
from the latent vector representations.

###  6.3 Qualitative Analyses

(a) roberta-large-mnli-help

(b) roberta-large-mnli-help

(c) roberta-large-mnli

(d) roberta-large-mnli

Figure 3: UMAP projections of selected classification token representations
comparing roberta-large-mnli and the improved roberta-large-mnli-help, which
shows greater distinction between context monotonicity features.

##### Error Break-Downs

We are less concerned with the accuracy score (on NLI challenge sets) of a
given model as with the behavioural _systematicity_ visible in the errors, as
we are not interested in noisy errors which may be due to words or phrases
from outside the training domain. Consistent mis-classification for all
examples derived from a fixed context or insertion pair are actually _also_
strongly suggestive of a regularity in reasoning. The decomposed error
analyses paint a striking picture: we generally see that models trained on
MNLI routinely fail to distinguish between the expected behaviour of upward
and downward monotone contexts, despite generally achieving high accuracies on
large benchmark sets. This is in accordance with observations in Yanaka et al.
(2019b) Yanaka et al. (2019a), where low accuracy on the downward-monotone
reasoning sections of challenge sets points to this possibility. Howver, they
show consistently show strong behavioural regularity with respect to concept
inclusion. Even when the contexts are downward monotone, they still treat them
systematically as if they were _upward_ monotone, echoing the concept
insertion pair relation _only_ : they completely fail to discriminate between
upward/downward monotone contexts and their opposite behaviours.

##### Visualization

Each data point corresponds to an embedded example ([CLS]) in the NLI-$XY$
dataset, with the left and right columns colored with the _gold_ auxiliary
labels for context monotonicity and concept inclusion relations respectively.
These illustrate the probing observations: in the well-known roberta-large-
mnli model, concept inclusion relation features are distinguishable, whereas
context monotonicity is very randomly scattered, with no emergent clustering.
However, the roberta-large-mnli-help model shows an improvement in this
behaviour, demonstrating a stronger context monotonicity distinction.

##  7 Conclusion

In summary, the NLI-$XY$ has enabled us to present evidence that explicit
context monotonicity feature clustering in neural model representations seems
to correspond to better performance on natural logic challenge sets which test
downward-monotone reasoning. In particular, many popular models trained on
MNLI seem to lack this behaviour, accounting for previous observations that
they systematically fail in downward-monotone contexts.

Furthermore, the probes’ labels also have some explanatory value: both
entailment and non-entailment labels can each further be broken down into sub-
regions. This qualifies the classification with the observations that the data
point occurs in a cluster of examples with a) upward (resp. downward) contexts
and b) a forward (resp. backward) containment relation between the substituted
noun phrases. In this sense, the analyses in this work can thus be interpreted
as an explainable “decomposition" of the treatment natural logic examples in
neural models.

## References

  * Abzianidze (2017) Lasha Abzianidze. 2017.  LangPro: Natural language theorem prover.  In _Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing: System Demonstrations_ , pages 115–120, Copenhagen, Denmark. Association for Computational Linguistics.
  * Alain and Bengio (2018) Guillaume Alain and Yoshua Bengio. 2018.  Understanding intermediate layers using linear classifier probes.
  * Bowman et al. (2015) Samuel R Bowman, Gabor Angeli, Christopher Potts, and Christopher D Manning. 2015\.  A large annotated corpus for learning natural language inference.  In _EMNLP_.
  * Chen et al. (2021) Zeming Chen, Qiyue Gao, and Lawrence S. Moss. 2021.  Neurallog: Natural language inference with joint neural and logical reasoning.
  * Devlin et al. (2019) 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.
  * Ferreira et al. (2021) Deborah Ferreira, Julia Rozanova, Mokanarangan Thayaparan, Marco Valentino, and André Freitas. 2021.  Does my representation capture X? probe-ably.  In _Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing: System Demonstrations_ , pages 194–201, Online. Association for Computational Linguistics.
  * Geiger et al. (2020) Atticus Geiger, Kyle Richardson, and Christopher Potts. 2020.  Neural natural language inference models partially embed theories of lexical entailment and negation.  In _Proceedings of the Third BlackboxNLP Workshop on Analyzing and Interpreting Neural Networks for NLP_ , pages 163–173, Online. Association for Computational Linguistics.
  * Goodwin et al. (2020) Emily Goodwin, Koustuv Sinha, and Timothy J. O’Donnell. 2020.  Probing linguistic systematicity.  In _Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics_ , pages 1958–1969, Online. Association for Computational Linguistics.
  * Herlihy and Rudinger (2021) Christine Herlihy and Rachel Rudinger. 2021.  MedNLI is not immune: Natural language inference artifacts in the clinical domain.  In _Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 2: Short Papers)_ , pages 1020–1027, Online. Association for Computational Linguistics.
  * Hewitt and Liang (2019) John Hewitt and Percy Liang. 2019.  Designing and interpreting probes with control tasks.  In _Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP)_ , pages 2733–2743, Hong Kong, China. Association for Computational Linguistics.
  * Hewitt and Manning (2019) John Hewitt and Christopher D. Manning. 2019.  A structural probe for finding syntax in word representations.  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 4129–4138, Minneapolis, Minnesota. Association for Computational Linguistics.
  * Hu et al. (2020) Hai Hu, Qi Chen, Kyle Richardson, Atreyee Mukherjee, Lawrence S. Moss, and Sandra Kuebler. 2020.  MonaLog: a lightweight system for natural language inference based on monotonicity.  In _Proceedings of the Society for Computation in Linguistics 2020_ , pages 334–344, New York, New York. Association for Computational Linguistics.
  * Hu and Moss (2018) Hai Hu and Larry Moss. 2018.  Polarity computations in flexible categorial grammar.  In _Proceedings of the Seventh Joint Conference on Lexical and Computational Semantics_ , pages 124–129, New Orleans, Louisiana. Association for Computational Linguistics.
  * Kalouli et al. (2020) Aikaterini-Lida Kalouli, Richard Crouch, and Valeria de Paiva. 2020.  Hy-NLI: a hybrid system for natural language inference.  In _Proceedings of the 28th International Conference on Computational Linguistics_ , pages 5235–5249, Barcelona, Spain (Online). International Committee on Computational Linguistics.
  * Lewis et al. (2020) Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Veselin Stoyanov, and Luke Zettlemoyer. 2020.  BART: Denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension.  In _Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics_ , pages 7871–7880, Online. Association for Computational Linguistics.
  * Lewis et al. (2021) Patrick Lewis, Pontus Stenetorp, and Sebastian Riedel. 2021.  Question and answer test-train overlap in open-domain question answering datasets.  In _Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume_ , pages 1000–1008, Online. Association for Computational Linguistics.
  * Liu et al. (2019) Y. Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, M. Lewis, Luke Zettlemoyer, and Veselin Stoyanov. 2019.  Roberta: A robustly optimized bert pretraining approach.  _ArXiv_ , abs/1907.11692.
  * MacCartney and Manning (2007) Bill MacCartney and Christopher D. Manning. 2007.  Natural logic for textul inference.  In _Proceedings of the ACL-PASCAL Workshop on Textual Entailment and Paraphrasing_ , pages 193–200, Prague. Association for Computational Linguistics.
  * McCoy et al. (2019) Tom McCoy, Ellie Pavlick, and Tal Linzen. 2019.  Right for the wrong reasons: Diagnosing syntactic heuristics in natural language inference.  In _Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics_ , pages 3428–3448, Florence, Italy. Association for Computational Linguistics.
  * McInnes et al. (2018) L. McInnes, J. Healy, and J. Melville. 2018.  UMAP: Uniform Manifold Approximation and Projection for Dimension Reduction.  _ArXiv e-prints_.
  * Pimentel et al. (2020) Tiago Pimentel, Naomi Saphra, Adina Williams, and Ryan Cotterell. 2020.  Pareto probing: Trading off accuracy for complexity.  In _Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)_ , pages 3138–3153, Online. Association for Computational Linguistics.
  * Richardson et al. (2019) Kyle Richardson, Hai Hu, Lawrence S. Moss, and Ashish Sabharwal. 2019.  Probing natural language inference models through semantic fragments.  _CoRR_ , abs/1909.07521.
  * Rozanova et al. (2021) Julia Rozanova, Deborah Ferreira, Mokanarangan Thayaparan, Marco Valentino, and André Freitas. 2021.  Supporting context monotonicity abstractions in neural nli models.
  * Sanchez (1991) V. Sanchez. 1991.  Studies on natural logic and categorial grammar.
  * Vulić et al. (2020) Ivan Vulić, Edoardo Maria Ponti, Robert Litschko, Goran Glavaš, and Anna Korhonen. 2020.  Probing pretrained language models for lexical semantics.  In _Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)_ , pages 7222–7240, Online. Association for Computational Linguistics.
  * Williams et al. (2018) Adina Williams, Nikita Nangia, and Samuel Bowman. 2018.  A broad-coverage challenge corpus for sentence understanding through inference.  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 1112–1122. Association for Computational Linguistics.
  * Wolf et al. (2020) Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, Joe Davison, Sam Shleifer, Patrick von Platen, Clara Ma, Yacine Jernite, Julien Plu, Canwen Xu, Teven Le Scao, Sylvain Gugger, Mariama Drame, Quentin Lhoest, and Alexander M. Rush. 2020.  Transformers: State-of-the-art natural language processing.  In _Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations_ , pages 38–45, Online. Association for Computational Linguistics.
  * Yanaka et al. (2019a) Hitomi Yanaka, Koji Mineshima, Daisuke Bekki, Kentaro Inui, Satoshi Sekine, Lasha Abzianidze, and Johan Bos. 2019a.  Can neural networks understand monotonicity reasoning? In _Proceedings of the 2019 ACL Workshop BlackboxNLP: Analyzing and Interpreting Neural Networks for NLP_ , pages 31–40, Florence, Italy. Association for Computational Linguistics.
  * Yanaka et al. (2019b) Hitomi Yanaka, Koji Mineshima, Daisuke Bekki, Kentaro Inui, Satoshi Sekine, Lasha Abzianidze, and Johan Bos. 2019b.  HELP: A dataset for identifying shortcomings of neural models in monotonicity reasoning.  In _Proceedings of the Eighth Joint Conference on Lexical and Computational Semantics (*SEM 2019)_ , pages 250–255, Minneapolis, Minnesota. Association for Computational Linguistics.
  * Zhang and Bowman (2018) Kelly Zhang and Samuel Bowman. 2018.  Language modeling teaches you more than translation does: Lessons learned through auxiliary syntactic task analysis.  In _Proceedings of the 2018 EMNLP Workshop BlackboxNLP: Analyzing and Interpreting Neural Networks for NLP_ , pages 359–361, Brussels, Belgium. Association for Computational Linguistics.