Improving Large Language Models in Event Relation Logical Prediction (2024)

Abstract: Event relations are crucial for narrative understanding and reasoning. Governed by nuanced logic, event relation extraction (ERE) is a challenging task that demands thorough semantic understanding and rigorous logical reasoning. In this paper, we conduct an in-depth investigation to systematically explore the capability of LLMs in understanding and applying event relation logic. More in detail, we first investigate the deficiencies of LLMs in logical reasoning across different tasks. Our study reveals that LLMs are not logically consistent reasoners, which results in their suboptimal performance on tasks that need rigorous reasoning. To address this, we explore three different approaches to endow LLMs with event relation logic, and thus enable them to generate more coherent answers across various scenarios. Based on our approach, we also contribute a synthesized dataset (LLM-ERL) involving high-order reasoning for evaluation and fine-tuning. Extensive quantitative and qualitative analyses on different tasks also validate the effectiveness of our approaches and provide insights for solving practical tasks with LLMs in future work. Codes are available at https://github. com/chenmeiqii/Teach-LLM-LR.

text: Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 9451–9478 August 11-16, 2024 ©2024 Association for Computational Linguistics
Event relations are crucial for narrative understanding and reasoning. Governed by nuanced logic, event relation extraction (ERE) is a challenging task that demands thorough semantic understanding and rigorous logical reasoning. In this paper, we conduct an in-depth investigation to systematically explore the capability of LLMs in understanding and applying event relation logic. More in detail, we first investigate the deficiencies of LLMs in logical reasoning across different tasks. Our study reveals that LLMs are not logically consistent reasoners, which results in their suboptimal performance on tasks that need rigorous reasoning. To address this, we explore three different approaches to endow LLMs with event relation logic, and thus enable them to generate more coherent answers across various scenarios. Based on our approach, we also contribute a synthesized dataset (LLM-ERL) involving high-order reasoning for evaluation and fine-tuning. Extensive quantitative and qualitative analyses on different tasks also validate the effectiveness of our approaches and provide insights for solving practical tasks with LLMs in future work. Codes are available at https://github. com/chenmeiqii/Teach-LLM-LR.

heading: 1 Introduction
text: Understanding the relationships between events is fundamental to effective communication and reasoning, a challenge central to the field of Event Relation Extraction (ERE). ERE tasks, which involve identifying coreference, temporal, causal, and subevent relationships, demand not only semantic comprehension but also rigorous logical reasoning. Despite recent advances in Large Language Models (LLMs) such as ChatGPT (Ouyang
*This work was done during her internship at Microsoft Research Asia.
†Corresponding author.
et al., 2022) and Llama2 (Touvron et al., 2023), these models struggle to fully grasp the complexities of event relation logic, often failing to apply it accurately in ERE tasks.
As showcased in Figure 1, ChatGPT incorrectly predicts the temporal and causal relations between events “FIRE” and “collapsed” as “simultaneous” and “cause”, respectively. According to the prior logical constraints, we could readily claim the predictions are not fully correct even before reading the context. Some works (Xu et al., 2023; Pan et al., 2023; Lyu et al., 2023) attribute this gap in logic adherence to LLMs’ inherent deficiencies (e.g., hallucination, unfaithfulness). However, how to disentangle and improve the capability of LLMs in these tasks is still an open problem.
To deeply understand the deficiencies of LLMs in logical reasoning and explore the corresponding solutions, in this paper, we conduct an in-depth investigation of LLMs in solving reasoning tasks from multiple dimensions. Our experimental re-
9451
sults show that: 1) Even the cutting-edge LLMs still generate large amounts of inconsistent answers, e.g., over 60% of the answers from ChatGPT on the MAVEN-ERE (Wang et al., 2022a) dataset are logically inconsistent as shown in Figure 2; 2) Providing relevant logic to LLMs improves performance, but injecting irrelevant logic introduces fluctuations in results. Therefore, how to obtain the relevant logic and inject its information into LLMs is a nontrivial problem, deserving further exploration.
Based on these findings, we put forward a series of solutions to endow LLMs with event relation logic and generate more coherent answers. Here, we propose three different kinds of approaches according to the ways of logic acquisition: 1) Generative-based approach, which encourages LLMs to generate rationale themselves, inspired by CoT prompting (Wei et al., 2022b). In this paradigm, we find that incorporating logical constraints into LLM instruction will bring substantial improvements, but the uncertainty of the generated rationales may also bring some biases, leading to an incorrect subsequent answer; 2) Retrieval-based approach, which collects constraints from realistic data, then retrieves relevant contents and adds them to the LLM instruction. This kind of approach ensures the correctness of logic and significantly improves performance, but requires some handcrafted engineering; 3) Finetuning-based approach, which first constructs a high-order event relation logical prediction dataset (LLM-ERL), then uses it to fine-tune specialized LLMs. The finetuning dataset consists of multi-hop event relation logical prediction instances. This strategy encodes logic in model parameters inherently, making them more suitable for white-box LLMs. Therefore, how to choose the most suitable strategy can be a trade-off based on the practical scenario.
Furthermore, based on the above framework, we also conduct extensive quantitative and qualitative analyses to validate the effectiveness of the proposed approaches and provide insights for future work: 1) Directly using CoT to infer ERE tasks is limited by the inherent issues of LLMs, but incorporating logical constraints in the reasoning process can be beneficial; 2) Retrieval-based approaches can significantly reduce inconsistencies in LLM responses. Stronger models like GPT-4 can effectively perform retrievals by themselves, whereas weaker models require assistance in filtering relevant information. Besides, directly conveying constraints to LLMs is more effective than adding
post-processing operations based on the results; 3) When fine-tuned on LLM-ERL, LLMs such as Llama2-13B (Touvron et al., 2023) can achieve better performance, which validates the effectiveness of our proposed approaches.
Overall, the contributions of our paper can be summarized as follows:
• We provide an in-depth investigation of the logical inconsistency issue of current LLMs, highlighting their challenges in understanding event relation logic.
• We propose several solutions to endow LLMs with event relation logic and generate more coherent answers. Based on our approach, we construct a synthesized dataset (LLM-ERL) involving high-order reasoning to enhance LLMs.
• Experimental results on different tasks with quantitative and qualitative analyses further verify the effectiveness of our approach in endowing LLMs with event relation logic.

heading: 2 Event Relation Logic

heading: 2.1 Event Relations
text: In this subsection, we introduce four common types of event relations that are crucial for narrative comprehension and reasoning. Coreference relations: identify whether two event mentions refer to the same occurrence. Temporal relations: establish the chronological order of events. Causal relations: identify causality between events. Subevent relations: identify whether one event is a subcomponent of another. More descriptions of these event relations can be found in Appendix A.
Based on these four relations, event relation extraction (ERE) can be formulated as a multi-label classification problem, assigning one label for each relation type. Compared with other common tasks, ERE tasks should take more considerations about the logical constraints between event relations (e.g., as shown in Figure 1), and guarantee the predictions should conform to these constraints to avoid counterfactuals. Therefore, we need to rigorously consider the logical constraints between each event pair during prediction. To better measure the capability of LLMs on the ERE task, we formulate the logical consistency metric.

heading: 2.2 Logical Consistency Between Event Relations
text: Logical consistency plays a crucial role in accurate event relation prediction. In this paper, we consider a comprehensive set including 11 logical constraints applicable to all possible relations between two events, which are derived from realistic data and are detailed in Appendix B. To quantify LLMs’ adherence to these constraints, we introduce a metric called Logical Inconsistency (LI). This metric is calculated as the proportion of conflicts (i.e., the answers that conflict with the known logical constraints) to the total possible relation combinations (i.e., all combinations between any two relation types).
To better illustrate the computation of LI, here we introduce an example (as shown in Figure 1): if an LLM outputs the relations between two events as “NO_COREFERENCE, SIMULTANEOUS, CAUSE, NO_SUBEVENT”. Among these, “SIMULTANEOUS” and “CAUSE” are identified as conflicting with each other based on the logical constraints we have defined, creating an inconsistency. Considering there are four relation types to assess for each event pair, the total number of relation combinations is determined by the formula: C24 = 6. Thus in this example, with one identified conflict, LI is computed as 1/6 (or approximately 16.7%). Based on the logical constraints, an algorithm can be designed to automatically detect conflicts and calculate the value of LI. Intuitively, the smaller the value of LI is, the more coherent and reasonable answer that LLM can produce.

heading: 3 Unveiling LLMs in Logical Reasoning
text: Considering the rigorous logical reasoning required by ERE tasks, in this section, we conduct a pilot study to investigate how current LLMs exhibit reasoning tasks and how logic benefits LLMs.

heading: 3.1 Data Source
text: We conduct a manual evaluation on MAVENERE (Wang et al., 2022a) and ProofWriter (Tafjord et al., 2021). MAVEN-ERE is a unified large-scale dataset for the ERE task, which needs to identify four types of relations. ProofWriter is a commonly used dataset for deductive reasoning, where each example is a pair of (problem, goal) and the label is selected from {Proved, Disproved, Unknown}. To employ our investigation, we randomly choose 100 samples (50 from MAVEN-ERE and 50 from ProofWriter).

heading: 3.2 Experimental Setup
text: Our experiments are conducted in a zero-shot fashion. Given a task input (X), we also write a prompt (T ) describing the task, and let LLM generate output (Y ) by answering the given query. We also add “Let’s think step by step” before each answer for prediction generation, which is a simple but effective trick to improve zero-shot reasoning for LLMs (Kojima et al., 2022). We adopt ChatGPT as the backbone and manually check its generated rationales under the following three settings:
• Vanilla LLM (i.e., ChatGPT) without any additional information;
• LLM (i.e., ChatGPT) plus the most relevant (i.e., ground truth) logic;
• LLM (i.e., ChatGPT) plus irrelevant logical constraints.
The latter two use a multi-turn conversational way based on the initial prediction from LLMs, so as to leverage LLM’s interaction ability. The process of determining constraints for each way and the corresponding prompt examples can be found in Appendix J.1.

heading: 3.3 Analysis
text: As shown in Figure 2, we visualize the micro-F1 values and the proportion of logically inconsistent answers generated by ChatGPT. We find that no matter whether on MAVEN-ERE or ProofWriter, Vanilla ChatGPT always achieves a bad result with low micro-F1 performance and high inconsistency values (e.g., 15% micro-F1 and 63% inconsistent answers on MAVEN-ERE), which indicates the deficiencies of LLM in solving complex reasoning tasks. To investigate this issue in depth, we conduct analyses from the following two aspects.
What is the Relation Between Logical Consistency and Model Performance? From Figure 2, we find that: 1) The model directly receives significant improvements on both MAVEN-ERE and ProofWriter when adding relevant logic; 2) When adding some irrelevant logic, the results show some fluctuations (exaltation in MAVEN-ERE and degeneration in ProofWriter). That means directly adding logic without any constraints will bring some uncertainty; 3) Typically, a higher logical inconsistency corresponds to a poorer micro-F1. However, rectifying logical inconsistency does not necessarily lead to the same degree of increase in micro-F1. Generally, an intuitive observation is that incorporating relevant logic into the LLM instruction will be very helpful in solving reasoning tasks. Therefore, the challenges are how to obtain these relevant logic and how to utilize them for LLMs.

heading: What Types of Errors Does LLM Usually Make?
text: To delve into a deep understanding of the failures that vanilla LLM encounters in logical reasoning, we also conduct a detailed error analysis. Here, we divide the error types into two aspects: 1) Incorrectness to the Constraint (CE): whether the rationale generated by LLM is wrong (CE1), incomplete (CE2), or redundant (CE3) compared with the true logical constraints. 2) Unfaithfulness to the Reasoning Process (FE): where LLM does not correctly use the constraints. We define two types of errors upon FE, i.e., i) Wrong start, LLM begins with an irrelevant fact or focuses on an improper perspective for the correct answer (FE1). ii) Wrong process, LLM starts from a proper point, but makes mistakes during the reasoning process (FE2). Annotators are asked to review 100 predictions generated by ChatGPT and mark the error types. Results in Figure 3 show that: 1) The quality of constraints produced by the vanilla ChatGPT
is not high enough, which limits its subsequent reasoning ability. 2) Incorporating relevant logical constraints could guarantee the correctness of constraints and thus greatly improve the generation quality of ChatGPT in faithfulness.

heading: 4 Teaching LLMs to Predict Event Relation Logic
text: From the above analysis, the main reason for the failure of LLMs stems from their lack of logical reasoning abilities. In this section, we expect to explore how to augment LLMs with the capability to comprehend and apply event relation logic. Specifically, we first introduce the instruction-following technique used in Section 4.1 and then propose three different approaches to instruct LLMs to generate answers with better logical consistency, including generative-based, retrieval-based, and finetuning-based approaches (Section 4.2 to 4.4). We illustrate these three approaches in Figure 4.

heading: 4.1 In-Context Learning for LLMs
text: We deploy LLMs for event relation logical prediction via in-context learning (ICL, (Brown et al., 2020; Ouyang et al., 2022)). Given a task input (X), we write a prompt (T ) describing the task, then further provide several demonstrations D = {Di}|D|i=1, where Di = (Xi, Yi) are used for few-shot learning. Then, the LLM generates the output (Y ) by completing the prompt (Y =M(T,D,X)), whereM denotes the LLM. In such a setting, the LLM can follow the structure of the provided demonstrations to output answers in the expected format for subsequent automatic evaluation. Additionally, the whole process does not require any gradient update, allowing LLMs to generate predictions without massive training data.

heading: 4.2 Generative-based Approaches
text: Generative-based approaches involve letting LLMs generate logic by using a form of few-shot ICL. Here, we study three variants:
Vanilla ICL: which utilizes the common prompts consisting of the task description, the demonstration, and the input case.
Vanilla CoT: which first bootstraps rationales by using chain-of-thought as intermediate reasoning steps following the style of the given demonstration, then output answers. Rationales here do not involve the content of logical constraints.

heading: OVERLAP CAUSE
text: CoT with self-generated logical constraints: which teaches LLMs to generate and utilize logical constraints based on CoT (shown in Figure 4 (a)). Specifically, it first extracts the obvious relations/facts and generates relevant logical constraints accordingly. LLMs are then prompted to infer the remaining relations and facts using these constraints along with the known information. An example prompt is provided in Appendix J.2.

heading: 4.3 Retrieval-based Approaches
text: Although generative-based approaches enable models to automatically generate and utilize logic, the generated rationales may be uncertain and inaccurate. Therefore, we also provide retrieval-based approaches, which aim to obtain relevant logic from our predefined logical set and add it to LLM instruction (shown in Figure 4 (b)). Specifically, we take all the constraints defined in Section 2.2 as the retrieval set, and our solutions include:
with all logical constraints: which directly adds all the text of logical constraints in the set.
with retrieved logical constraints: which means that we first detect logically inconsistent answers based on the prediction of LLMs, and then retrieve the corresponding information if we find any conflicts. Finally, we add the retrieved text to the LLM instruction and let LLMs regenerate the answers.
Details can be found in Appendix B.1.
with post-processing: which first obtains the answers of LLMs, then automatically generates some logically consistent candidates according to the known constraints, and randomly selects one of them as the final answer. This approach ensures that there are no logical conflicts (LI = 0%). Details can be found in Appendix B.2.

heading: 4.4 Finetuning-based Approach
text: Although the retrieval-based approach guarantees the correctness of logical constraints, it still needs to interact with an external logical set constantly. Therefore, we provide a finetuning-based approach to embed the logical constraints into LLMs themselves. Specifically, we first construct a high-order event relation logical prediction dataset LLM-ERL, then fine-tune specialized models on it, and finally use the fine-tuned models to conduct prediction.
To construct LLM-ERL, we initiate with a foundational set of logical constraints for relations between two events that have been defined in Section 2.2, and expand it to include additional constraints for high-order relations among three or more events based on transitive dependency (Allen, 1983; Gerevini and Schubert, 1995), i.e., one event may affect another through an intermediate event. The full transitivity rules are detailed in Appendix C (Table 6).
Dataset Construction Once obtaining the constraint set, the process of dataset construction becomes inferring new relations within a sequence of events based on any given relations. From there, we combine an initial relation with any other given relation to form a multi-hop query. This query aims to predict the logical outcome of a complex event interaction that spans multiple steps, leveraging the established logical constraints as a guide. For instance, if we have an initial relation “BEFORE(A, B)”, and we combine this with another two relations such as “SIMULTANEOUS(B, C)” and “OVERLAP(C, D)”, we are faced with a 3-hop query that seeks to deduce the relation between event A and event D. Given the logical constraints, such as the transitivity rule that combines “BEFORE” and “SIMULTANEOUS” relations to infer new relations, we can deduce a logical outcome “BEFORE(A, D)”. The corresponding pseudocode can be found in Appendix C.1.
The process of deducing the answer to these multi-hop queries is automated by employing logic programming (Lloyd, 2012; Frederiksen, 2008), specifically using forward- and backward-chaining methods in Prolog (Clocksin and Mellish, 2003). This allows for the automatic inference of new relations based on the established set of logical constraints and the known relations among events. The outcome of this process can not only serve as the benchmark for evaluating or enhancing the reasoning capabilities of LLMs, but also act as a versatile platform for validating combinations of event relations across any number of hops.
Fine-tuning on LLM-ERL To fine-tune LLMs on LLM-ERL, we use the generated 2 to 5-hop reasoning data. We do not adopt longer hop data here considering the computation complexity and the length limitation of LLMs. We translate the symbolic representations of event relations into natural language descriptions to formulate queries, aligning with the ERE task setup. This process resulted in a total of 6,776 instances. The dataset statistics are in Appendix D and an illustrative example of such a prompt is depicted in Figure 4 (c). These queries not only promote LLMs’ understanding of the logical constraints governing event sequences but also enhance their ability to apply these constraints in predicting the relations among events that are not explicitly given. Finally, we could conduct inference with the fine-tuned LLMs.

heading: 5 Experiments

heading: 5.1 Experimental Setup
text: Compared Models We choose several limitedaccess LLMs (gpt-3.5-turbo, text-davinci-003, and gpt-4), and open-source LLMs (Vicuna-13B (v1.3) (Chiang et al., 2023) and Llama2-13B (Touvron et al., 2023)) as the main experimental LLMs for evaluation. We also provide two fine-tuning RoBERTa-large (Liu et al., 2019) baselines (oneshot and fully fine-tuned) for comparison, the finetuning details can be found in Appendix F.
Dataset Construction Our main experiments are evaluated on two ERE datasets, MAVEN-ERE (Wang et al., 2020) and CausalTimeBank (Mirza et al., 2014). All experiments are conducted in a one-shot fashion. Further details can be found in Appendix E.
Fine-tuning Details For the finetuning-based approach, we adopt Vicuna-13B (v1.3) and Llama213B as the base models and employ the LoRA (Hu et al., 2022) technique. During fine-tuning, only LoRA parameters are optimized. The fined-tuned models are named Vicuna-FT and Llama2-FT, respectively. Further details can be found in Appendix G.
Evaluation Metrics We adopt the averaged micro-F1 score as the evaluation metric and also report the logical inconsistency metric LI (defined in Section 2.2) on ERE datasets. The reported value is averaged by the results of three runs to reduce random fluctuation.

heading: 5.2 Main Results
text: From Table 1, We could observe that:
Generative-based Approaches 1) Compared with a smaller language model RoBERTa-large, the generalization ability of vanilla LLMs under the one-shot setting is remarkable, but there is still a gap with the fully-finetuned baseline.
2) Directly using CoT to infer logic does not help much for ERE tasks, a possible reason is that the inherent issues of LLMs may cause them to fail in generating precise rationales (i.e., a high ratio of logical inconsistency).
3) When using generative-based approaches to encourage LLMs to produce logical constraints in the reasoning process, LLMs can significantly improve their performance on ERE tasks (e.g., 7.3%
The highlighted colors denote generative-based, retrieval-based, and finetuning-based approaches, respectively.
F1 performance gains from 18.0% to 25.3% of gpt3.5-turbo on MAVEN-ERE). We give a case study for the generative-based approach in Appendix I.1, which shows how LLMs perform when generating logical constraints by themselves.
Retrieval-based Approaches 1) When using retrieval-based approaches to obtain logic constraints and incorporate them into LLM instruction, the logical inconsistency of LLMs’ answers is greatly reduced and the overall performance is fur-
ther improved (e.g., 6.2% F1 performance gains from 21.6% to 27.8%, and 18.3% LI decrease from 49.1% to 30.8% of text-davinci-003 on the MAVEN-ERE dataset).
2) Among all the limited-access models, we find that only gpt-4 perform better under the “w. all logical constraints” setting compared with the “w. retrieved logical constraints” setting. We hypothesize that this is due to the superior language understanding and retrieval capabilities of gpt-4, enabling it to identify some useful logical constraints to derive the answers accurately. In contrast, earlier models may struggle to filter out irrelevant information and therefore still require our assistance in retrieval to screen the necessary information.
3) Although the post-processing baseline guarantees the absence of logical conflicts (resulting in LI of 0%), it may severely affect the quality of the whole generation. On one hand, the semantics of the post-processing answer may be far from the ground truth due to the random selection. On the other hand, the size of the candidate set for each case will also affect the performance. It may also need more operations at the post-processing stage, which we leave as future work. We also conduct ablation studies on the number of demonstration samples and iterative retrievals in Section 5.3.
Finetuning-based Approach 1) Once fine-tuned on LLM-ERL, the performance of Llama2-FT and Vicuna-FT improves greatly compared with vanilla Llama2 and Vicuna, especially on the baselines without logical constraints.
2) The performance of Llama2-FT (i.e., 26.4% F1 score on MAVEN-ERE) could even surpass that of some greater LLMs (e.g., vanilla gpt-3.5-turbo, 25.3%), which further validates the importance of teaching LLM with event relation logic in solving ERE tasks. We also conduct a case study comparing the output answers of Llama2 and Llama2-FT in Appendix I.2.

heading: 5.3 Ablation Study
text: We conduct an ablation study using ChatGPT (gpt3.5-turbo) in this section.
Demonstrations Following previous experiences (Brown et al., 2020), we also append demonstrations into the prompt to investigate how logical constraints will affect when combined with different numbers of demonstrations. Here, we select different numbers of demonstration samples K from {1, 5, 10, 20}. The experiments are tested
on the “w. all logical constraints” settings, and we choose the “vanilla ICL” baseline for comparison. From Figure 5 (left), we can observe that: 1) When the number of demonstrations increases from 1 to 5, there is an evident performance improvement, but the subsequent improvements are limited when continue to increase the number of demonstrations (e.g., ≥ 10); 2) Adding logical constraints into LLM instructions can provide stable improvements, especially with more demonstrations; 3) The performance of incorporating logical constraints with a smaller number of demonstrations can even surpass that of prompts with only a larger number of demonstrations (e.g., the F1 performance of using 5 demonstrations on MAVEN-ERE w. logical constraints, 25.7%, surpasses that of 10 demonstrations w/o. logical constraints, 24.5%). This indicates that it is important to tell LLMs both “What” (demonstrations) and “How” (logical constraints). Overall, these studies further confirm the merits of using event relation logic in solving ERE tasks.
Iterative Retrieval Considering the outstanding ability of LLMs in interaction, we further explore whether we can introduce logical constraints into the multi-turn conversation (for the prompt design, please see Appendix J.3). Here, we adopt a retrieval-based approach to incorporate retrieved logical constraints iteratively and the results are shown in Figure 5 (right). We find that the logical inconsistency of answers will gradually decrease with the increase of iterations, but the overall microF1 score seems relatively stable. We guess the main reason for this phenomenon is the overthinking of LLMs, as although it can bring more reasoning rationale, it possibly produces correct but more useless or abundant information when inferring multiple iterations. Overall, instructing LLM with logic is beneficial for conversation, but how to support longer information is still challenging.

heading: 6 Related Work

heading: 6.1 Large Language Models (LLMs)
text: We are fortunate to witness the surging development of Large Language Models (LLMs (Brown et al., 2020; Ouyang et al., 2022; Chowdhery et al., 2022; Chung et al., 2022)), and a series of work aiming to leverage the reasoning abilities of LLMs such as chain-of-thought prompting (Wei et al., 2022a; Kojima et al., 2022; Zhang et al., 2022), self verification (Wang et al., 2022c; Jung et al., 2022), self learning (Zelikman et al., 2022; Huang et al., 2022), etc. However, recent studies show LLMs still stumble in generating hallucination and logic inconsistency (Golovneva et al., 2022; Jang and Lukasiewicz, 2023; Bang et al., 2023; Liu et al., 2023; Jiao et al., 2023). To solve such challenges, our work explores teaching LLMs logical reasoning through various approaches.

heading: 6.2 Event Relation Extraction (ERE)
text: Events play crucial roles in comprehending narratives, and understanding the complex relationships between events is essential to understanding the text (Sundheim, 1991). Thus ERE tasks are fundamental information extraction (IE) tasks and support various downstream applications (Chaturvedi et al., 2017; Zhang et al., 2020). Extensive studies have been carried out on ERE tasks, including different kinds of relations such as coreference relations (Lu and Ng, 2021; Lu et al., 2022), temporal relations (Ning et al., 2018; Wang et al., 2020; Han et al., 2019; Zhou et al., 2021), causal relations (Caselli and Vossen, 2017; Chen et al., 2022, 2023), and subevent relations (Aldawsari and Finlayson, 2019; Wang et al., 2021).
There also have been some recent explorations on how to leverage the power of LLMs on eventrelated information extraction tasks (Wang et al., 2022b; Gao et al., 2023; Ma et al., 2023; Qiu et al., 2023; Yuan et al., 2024). To the best of our knowledge, however, our work is the first to 1) design elaborate experiments to evaluate the performance of LLMs on the ERE task, including coreference, temporal, causal, and subevent relations, 2) delve into the high-order logical constraints between these event relations, and (3) analyze the logical reasoning abilities of LLMs using ERE as an intermediate task.

heading: 7 Conclusion
text: In this paper, we conduct a detailed investigation on how to enhance LLMs with event relation logic. Specifically, we first investigate the existing issues of current LLMs in event relation logical prediction. Then, we study multiple strategies to obtain and utilize logic for LLMs, including generative-based, retrieval-based, and finetuning-based approaches. Based on our approaches, we also contribute a synthesized dataset (LLM-ERL) involving multi-hop reasoning for evaluation and fine-tuning. We show that LLMs are not logically consistent reasoners, but their performance could be improved if we explicitly teach them the logical constraints. Comprehensive quantitative and qualitative analyses have been conducted to further provide insights.

heading: Limitations
text: Although we have explored a series of approaches in detail to enhance LLMs to generate more logically consistent answers and greatly improve their performance, we find that there is still a certain gap between this and the ideal situation (i.e., incorporating the most relevant logical constraints in Section 3). In view of the LLMs’ potential to understand logical constraints and make more rigorous reasoning, we believe that further exploration of how to make better use of logical constraints will help us understand the reasoning ability of LLMs, and we will take this as our future work.

heading: Acknowledgments
text: We thank all the anonymous reviewers for their valuable feedback throughout the review process. This work is also supported by Ucap Cloud.

heading: A Understanding Event Relations
text: There are four kinds of widely-used event relations: coreference, temporal, causal, and subevent relations (O’Gorman et al., 2016; Wang et al., 2022a).
1. Coreference relations between events occur when multiple event mentions in a text refer to the same underlying event. We call these event mentions cluster.
2. Temporal relations refer to the temporal ordering of events based on their occurrence in time. In this paper, we consider seven different types of temporal relations:
• NO_TEMPORAL: if there is no clear temporal relation between event A and B.
• BEFORE: if event A happened completely before event B.
• OVERLAP: if event A has an overlap with event B.
• CONTAINS: if event A’s time contains event B’s time.
• SIMULTANEOUS: if events A and B happen at the same time.
• ENDS-ON: if event A ends when event B starts.
• BEGINS-ON: if event A and event B start at the same time, but end at different times.
In Figure 6, we list all the types of temporal relations and illustrate their distinctions on a unified timeline. Note that in our study, we adhere to a unidirectional perspective where the start time of event A precedes that of event B. Consequently, our framework does not encompass symmetrical relationships, such as the inverse of “AFTER” being “BEFORE”. To illustrate, if event A is considered “AFTER” event B, this would correspond to event B being “BEFORE” event A in our defined context.
3. Causal relations refer to that one event (the cause) brings about or influences the occurrence of another event (the effect). They can be classified into two different types: CAUSE relation where the tail event is inevitable given the head event, and PRECONDITION where the tail event would not have happened if the head event had not happened.
4. Subevent relations refer to that one event (the subevent) is a component or a smaller part of
another event (the main event). Identifying and understanding subevent relations helps to reveal the underlying hierarchy and organizational structure of events in a given text.
Event Relation Extraction Event Relation Extraction (ERE) includes identifying coreference, temporal, causal, and subevent relations between every two events in the text. We formulate ERE as a multi-label classification problem, determining one label (relation) for each of these four relation types. For coreference relations, the labels ∈{NO_COREFERENCE, COREFERENCE}; for temporal relations, the labels∈ {NO_TEMPORAL, BEFORE, OVERLAP, CONTAINS, SIMULTANEOUS, ENDS-ON, BEGINS-ON}; for causal relations, the labels ∈ {NO_CAUSAL, PRECONDITION, CAUSE}; for subevent relations, the labels ∈ {NO_SUBEVENT, SUBEVENT}.

heading: B Logical Constraints Between Two Events
text: In Table 2, we provide a comprehensive set of logical constraints for the relations between two events to assess their logical consistency. We also manually design description text for each constraint to let LLMs follow the prompt. As shown in Table 5, COREFERENCE(A, B)→¬TEMPORAL(A, B), ¬CAUSAL(A, B), ¬SUBEVENT(A, B) indicates that "if event A and event B have a coreference relation, they will not have temporal, causal, and subevent relations".

heading: B.1 An Example of Detecting Conflicts and Retrieving Relevant Constraints
text: As described above, for the ERE task, we meticulously collect 11 logical constraints covering all
relations between two events. These constraints serve as our benchmark to identify inconsistencies in the predictions made by LLMs.
Let us consider an illustrative example. If LLM produces an answer such as “NO_COREFERENCE, SIMULTANEOUS, CAUSE, NO_SUBEVENT” (refer to Figure 1 and Figure 4), we could detect the inconsistency between “SIMULTANEOUS” and “CAUSE”, as shown in Table 2:
• A “SIMULTANEOUS” relation implies a “NO_CAUSAL” (¬CAUSAL) relation.
• Conversely, a “CAUSE” relation suggests the presence of either a “BEFORE” or an “OVERLAP” relation.
Given this, “SIMULTANEOUS” and “CAUSE” are inherently contradictory, and they cannot coexist in a consistent prediction. To rectify this, we retrieve the associated textual description from Table 5. Specifically, the statements “If event A CAUSEs event B, then event A happens BEFORE or OVERLAP event B ...” and “If event A and event B happen SIMULTANEOUSly, then they won’t have coreference, causal, and subevent relations ...” are integrated into the LLM’s instruction.

heading: B.2 An Example of Post-processing
text: As shown in Figure 4, if LLMs predict the relations between two events as “NO_COREFERENCE, SIMULTANEOUS, CAUSE, NO_SUBEVENT”, we can detect that “SIMULTANEOUS” and “CAUSE” conflict according to the logical constraints. In order to eliminate conflicts, one relation can be fixed first, and then the other relation can be randomly decided by the candidates that do not conflict with the current relation. For example, when the fixed temporal relation is “SIMULTANEOUS”,
the causal relations can only be “NO_CAUSAL”, while when the fixed causal relation is “CAUSE”, the temporal relation can be either “BEFORE” or “OVERLAP”. We also add a negative option “NO_COREFERENCE, NO_TEMPORAL, NO_CAUSAL, NO_SUBEVENT” to the candidate set because it is possible that neither relation exits. Finally, we randomly select one option from:
• NO_COREFERENCE, SIMULTANEOUS, NO_CAUSAL, NO_SUBEVENT
• NO_COREFERENCE, OVERLAP, CAUSE, NO_SUBEVENT
• NO_COREFERENCE, BEFORE, CAUSE, NO_SUBEVENT
• NO_COREFERENCE, NO_TEMPORAL, NO_CAUSAL, NO_SUBEVENT
as the ultimate answer, thus ensuring that the results must be logically consistent (i.e., LI = 0).

heading: C Transitivity Rules Among Events
text: We provide a comprehensive set of 39 logical constraints for the transitivity rules among three events in Table 6. We also manually design prompts for each constraint, as shown in Table 7.

heading: C.1 Pseudo Code of Logic Programming
text: Once obtaining 11 constraints between two events and 39 constraints among three events, we apply logic programming to automatically reason new event relations by inputting the known constraints and relations. The pseudo-code mentioned in the main text is shown in Algorithm 1.

heading: D Statistics of the Fine-tuning Dataset
text: As shown in Table 3, we provide the statistics of the fine-tuning dataset originating from LLM-ERL.

heading: E Dataset Construction
text: MAVEN-ERE contains 4,480 documents, 103,193 events coreference chains, 1,216,217 temporal relations, 57,992 causal relations, and 15,841 subevent relations, which is larger than existing datasets of all the ERE tasks by at least an order of magnitude (Wang et al., 2022a). MAVEN-ERE has released the train and valid set, but does not release the ground-truth test set, so we randomly split its train set into train/valid sets with a ratio of 8:2, and then use its original valid set as the new test set.
Causal-TimeBank contains 184 documents, 6,813 events, and 7,608 event pairs (Mirza and Tonelli, 2014). Among them, 318 and 6,115 event pairs are annotated with causal and temporal relations, respectively. Due to Causal-TimeBank does not split train/valid/test sets, we randomly split it to train/valid/test sets with a ratio of 6:1:3. We do not evaluate coreference and subevent relations in Causal-TimeBank since there are no annotations for these two relation types.
For ERE tasks, We conduct sampling at the sentence level. The samples of the two events that do not have any relations will be excluded. Note that Causal-TimeBank inherently contains fewer event relations compared to MAVEN-ERE. After processing and dividing the data split, its test set comprises only 139 samples. Therefore, we randomly sample 500 examples from the test set of MAVEN-ERE and 100 examples from the test set of Causal-TimeBank as our testbed.
ProofWriter is a commonly used dataset for deductive reasoning (Tafjord et al., 2021). We use the OWA subset of it, which is divided into five parts, each part requiring 0, 1, 2, 3, and 5 hops of
reasoning, respectively. We evaluate the hardest 5-hop subset. To reduce the computation cost, we randomly sample 200 examples in the test set and ensure a balanced label distribution.
FOLIO is a challenging expert-written dataset for logical reasoning (Tafjord et al., 2021), whose questions require complex first-order logic reasoning to solve. We use its entire test set for evaluation, consisting of 204 examples.
Algorithm 1 An Example of 3-hop Reasoning Initialize the knowledge base with facts and rules
Knowledge Base: Fact: BEFORE(A, B) Fact: SIMULTANEOUS(B, C) Fact: OVERLAP(C, D) Rule: BEFORE ← BEFORE ∧ SIMULTANEOUS Rule: OVERLAP← SIMULTANEOUS ∧ OVERLAP Rule: BEFORE←BEFORE∧OVERLAP
Initialize the logic engine with the query Query: BEFORE(A, D)?
while obtain new facts do for each rule r of the Knowledge Base do
if r’s premise is satisfied by the current known facts then
Add r’s conclusion to the knowledge base
end if end for
end while
Query result: BEFORE(A, D) is satisfied with BEFORE(A, C) and OVERLAP(B, D)

heading: F Training Details of RoBERTa-large On Two Tasks
text: Our experiments include two settings. (1) fully fine-tuned: we fine-tune smaller language models (SLMs) with complete and abundant samples. This setting is for reference to see the performance limit of SLMs. (2) one-shot: we sample only one example for each label and construct a tiny training set. This setting is for direct comparison with our experiments on LLMs (similar training/demonstration sample number).

heading: Model (%) ProofWriter FOLIO
text: We implement vanilla fine-tuning approaches on two datasets and use RoBERTa-Large as backbones. We run each experiment on a single NVIDIA V100 GPU. We adopt the AdamW (Loshchilov and Hutter, 2019) optimizer with a linear scheduler and 0.1 warm-up steps. We set the weight-decay coefficient as 1e-5 and maximum gradient norms as 1.0. We set the batch size as 16 with 20 or 50 epochs. We set the maximum input length as 256 and the learning rate as 2e-5.
G Implementation Details of Finetuning-based Approach
We set the rank of LoRA modules to be 64. Our model is optimized with a learning rate of 2e-4 and a linear warm-up for the first 3% steps. We clip the gradients of model parameters to a max norm of 0.3. All the LoRA parameters are fine-tuned on an NVIDIA A100 GPU with 80GB memory.

heading: H Generalization to Logical Reasoning
text: In this section, we verify whether LLMs enhanced by LLM-ERL can be generalized to other tasks that need logical reasoning. We translate the symbolic representations of event relations into a form of deductive reasoning (i.e., containing facts, rules, and queries) to maintain consistency in task settings. The prompt example can be found in Appendix J.4.
Dataset Construction We conduct experiments on two datasets: ProofWriter (Tafjord et al., 2021) and FOLIO (Han et al., 2022). Details of the datasets can be found in Appendix E.
Results As shown in Table 4, we are surprised to find that models fine-tuned on LLM-ERL (e.g., Llama2-FT) can also bring performance improvement on other logical reasoning datasets, even though LLM-ERL focuses on event relation logic. This shows that the logical reasoning ability acquired by LLMs in the fine-tuning process can be
generalized to other domains. We intend to explore this intriguing aspect in future work.

heading: I Case Study

heading: I.1 Case Study on Self-generated Logical Constraints
text: In the main context, we have found that directly using CoT to infer logic does not help much for ERE tasks. One possible reason is that the inherent issues may lead to the failure of LLM in the precise rationale generation. To further illustrate an intuitive impression, we conduct a case study on MAVEN-ERE and find that the logical constraints generated by LLMs themselves are often inaccurate in content. As shown in Figure 7, ChatGPT could follow the logical constraint provided in the demonstration to a certain extent. However, it wrongly applies this to other relations — knowing that event A is event B’s precondition, it is wrong to think that event B will cause event A. Actually, according to the logical constraints in Table 2, the relations between (B, A) should be “NO_COREFERENCE, NO_TEMPORAL, NO_CAUSAL, NO_SUBEVENT”.

heading: I.2 Case Study on Llama2 and Llama2-FT
text: In Figure 8, We conduct a case study of Llama213B’s answers to the same input before and af-
ter fine-tuning. From Figure 8 we can see that Llama2-FT could output the correct answers after fine-tuning on LLM-ERL, which validates the effectiveness of our fine-tuning approach.

heading: J Prompt Examples
text: In this section, we provide examples of prompts used for each task and approach.

heading: J.1 Pilot Case Study
text: In the context of our paper, “relevant logical constraints” refer to the necessary knowledge or requirements for processing the current sample. They are accurately defined and closely related to the case in question. On the other hand, “irrelevant logical constraints” denote logic that, while possibly correct in content, does not directly pertain to the specific sample at hand. This distinction is crucial to maintain the focus and relevance of our analysis.

heading: Process of Determining Relevant Logic
text: • For MAVEN-ERE: we have presented the critical importance of ensuring the logical consistency of answers generated by LLMs. Therefore, we implement a rigorous manual check of the LLM outputs. During this process, we specifically identify and rectify any logical inconsistencies. We guide LLM by incorporating the most relevant logical constraints from Table 5 into the LLM’s instruction, thereby facilitating the refinement and accuracy of its responses.
• For ProofWriter: we have observed that the context often contains some facts and rules that are not directly pertinent to the current question. Therefore, we start by analyzing the question at hand and the initial answers provided by the LLM. Based on this, we selectively introduce rules and facts that are specifically relevant to the current scenario. This method allows us to provide the LLM with focused guidance, enabling it to refine its answers more effectively and accurately.

heading: Process of Determining Irrelevant Logic
text: • For MAVEN-ERE: We randomly sample 1-2 constraints from the entire set removing those relevant logical constraints and construct the prompts based on each sample.
• For ProofWriter: We artificially select irrelevant logical constraints from each sample’s content, thereby introducing a form of “noise” or “distraction” to the LLM’s judgment process.

heading: Prompt Examples
text: • MAVEN-ERE w. relevant logic constraints (Figure 9);
• MAVEN-ERE w. irrelevant logic constraints (Figure 10);
• ProofWriter w. relevant logic constraints (Figure 11);
• ProofWriter w. irrelevant logic constraints (Figure 12).
J.2 Incoporating Logical Constraints The highlighted parts represent the content generated by LLMs. We omit the demonstration here for clarity.
Vanilla ICL Task Description: There is a piece of text with two events marked by < and > symbols, and your task is to identify four types of relations between them (··· more context here ··· )
Text: Before her death , Todd posted a video on YouTube in which she used a series of flash cards to < tell > her experience of being blackmailed into exposing her breasts via webcam , and of being < bullied > and physically assaulted .
Event Pairs: < tell > and < bullied > < bullied > and < tell >
Answers: NO_COREFERENCE, NO_TEMPORAL, NO_CAUSAL, NO_SUBEVENT. NO_COREFERENCE, NO_TEMPORAL, PRECONDITION, NO_SUBEVENT.
Vanilla ICL plus CoT Task Description: There is a piece of text with two events marked by < and > symbols, and your task is to identify four types of relations between them (··· more context here ··· )
Text: Before her death , Todd posted a video on YouTube in which she used a series of flash cards to < tell > her experience of being blackmailed into exposing her breasts via webcam , and of being < bullied > and physically assaulted .
Event Pairs: < tell > and < bullied > < bullied > and < tell >
Reasoning: < bullied > happens before < tell >, and being < bullied > leads her to < tell >. Answers: NO_COREFERENCE, BEFORE, NO_CAUSAL, NO_SUBEVENT. NO_COREFERENCE, BEFORE, PRECONDITION, NO_SUBEVENT.
CoT w. self-generated logical constraints Task Description: There is a piece of text with two events marked by < and > symbols, and your task is to identify four types of relations between them (··· more context here ··· )
Text: Before her death , Todd posted a video on YouTube in which she used a series of flash cards to < tell > her experience of being blackmailed into exposing her breasts via webcam , and of being < bullied > and physically assaulted .
Event Pairs: < tell > and < bullied > < bullied > and < tell >
From the text, we could first get: < bullied > happens before < tell >, and being < bullied > leads her to < tell > Due to the logical constraint: If event 𝐴 is event 𝐵’s PRECONDITION, then event A happens BEFORE or OVERLAP event B, and they won’t have coreference and subevent relations, and event B has NO_TEMPORAL relation with event A. We can deduce that the answers are: NO_COREFERENCE, NO_TEMPORAL, NO_CAUSAL, NO_SUBEVENT. NO_COREFERENCE, BEFORE, PRECONDITION, NO_SUBEVENT.
w. all logical constraints Task Description: There is a piece of text with two events marked by < and > symbols, and your task is to identify four types of relations between them (··· more context here ··· )
Logical constraints: There are some rules among the relations, you can select some of them to reason or check your answers: (1) If two events are COREFERENCE, then they won’t have temporal, causal, and subevent relations, and COREFERENCE relation is bidirectional. (··· more context here ··· ) (11) If event B is a SUBEVENT of event A, then they won’t have coreference and causal relations, and event A’s time should CONTAINS event B’s time, and event B has NO_TEMPORAL relation with event A.
Text: Before her death , Todd posted a video on YouTube in which she used a series of flash cards to < tell > her experience of being blackmailed into exposing her breasts via webcam , and of being < bullied > and physically assaulted .
Event Pairs: < tell > and < bullied > < bullied > and < tell >
Answers: NO_COREFERENCE, NO_TEMPORAL, NO_CAUSAL, NO_SUBEVENT. NO_COREFERENCE, BEFORE, PRECONDITION, NO_SUBEVENT.
w. retrieved logical constraints Task Description: There is a piece of text with two events marked by < and > symbols, and your task is to identify four types of relations between them (··· more context here ··· )
Logical constraints: There are some rules among the relations, you can select some of them to reason or check your answers: (1) If event A is event B’s PRECONDITION, then event A happens BEFORE or OVERLAP event B, and they won’t have coreference and subevent relations, and event B has NO_TEMPORAL relation with event A. (2) If event A and event B do not have a temporal relation, then they won’t have causal and subevent relations.
Text: Before her death , Todd posted a video on YouTube in which she used a series of flash cards to < tell > her experience of being blackmailed into exposing her breasts via webcam , and of being < bullied > and physically assaulted .
Event Pairs: < tell > and < bullied > < bullied > and < tell >
Answers: NO_COREFERENCE, NO_TEMPORAL, NO_CAUSAL, NO_SUBEVENT. NO_COREFERENCE, BEFORE, PRECONDITION, NO_SUBEVENT.
J.3 Iterative Retrievals In this section, we present a prompt example used in Section 5.3. As shown in Figure 13, with iterative prompting, ChatGPT finally outputs the correct answers.

heading: J.4 Deductive Reasoning
text: The highlighted parts represent the content generated by LLMs. We omit the demonstration here for clarity.
Vanilla ICL Task Description: Given a problem statement as contexts, the task is to answer a logical reasoning question. For each question, choose from the following options: A) True, B) False, or C) Unknown.
Context: The cow likes the lion. The cow visits the tiger. (··· more context here ··· )
Question: Based on the above information, is the following statement true, false, or unknown? The tiger is not young.
The correct option is: C.
Vanilla ICL plus CoT Task Description: Given a problem statement as contexts, the task is to answer a logical reasoning question. For each question, choose from the following options: A) True, B) False, or C) Unknown.
Context: The cow likes the lion. The cow visits the tiger. (··· more context here ··· )
Question: Based on the above information, is the following statement true, false, or unknown? The tiger is not young.
Reasoning: The tiger likes the cow. The tiger likes the squirrel. If something likes the squirrel and it likes the cow, then it visits the tiger. So the tiger visits the tiger. If something visits the tiger then it is nice. So the tiger is nice. If something is nice and it sees the tiger then it is young. So the tiger is young. The correct option is: B.
CoT w. self-generated logical constraints Task Description: Given a problem statement as contexts, the task is to answer a logical reasoning question. For each question, choose from the following options: A) True, B) False, or C) Unknown.
Context: The cow likes the lion. The cow visits the tiger. (··· more context here ··· )
Question: Based on the above information, is the following statement true, false, or unknown? The tiger is not young.
From the text, we could first get facts: The tiger likes the cow. The tiger likes the squirrel. Due to the mentioned rules: if something likes the squirrel and it likes the cow, then it visits the tiger. We can deduce the facts: the tiger visits the tiger. Due to the mentioned rules: if something visits the tiger then it is nice. We can deduce the facts: the tiger is nice. Due to the mentioned rules: if something is nice and it sees the tiger then it is young. We can deduce the facts: the tiger is young. Therefore, the correct option is: B.

heading: Future Work
text: We intend to explore this intriguing aspect in future work