## Diagram: Structure-Aware Logical Fallacy Detection Process ### Overview The image is a technical flowchart illustrating a two-path process for transforming natural language text into a standardized, logic-aware format for input into a Pretrained Natural Language Inference (NLI) model. The goal is to classify whether an input sentence contains a specific type of logical fallacy. The diagram is divided into two main vertical columns: "Structure-Aware Premise" on the left and "Structure-Aware Hypothesis" on the right, which converge at the bottom into a central model. ### Components/Axes The diagram has no traditional chart axes. Its components are text boxes, arrows, and a central processing node. **1. Main Columns:** * **Left Column Header:** "Structure-Aware Premise" (blue background, white text). * **Right Column Header:** "Structure-Aware Hypothesis" (blue background, white text). **2. Central Processing Node:** * A light blue oval at the bottom center labeled "Pretrained NLI Model". * An arrow points from this oval to a final output box. **3. Final Output:** * A light blue box at the very bottom labeled: "[Classification] Whether the input sentence has the given type of the logical fallacy." **4. Flow Arrows:** Grey arrows indicate the direction of data transformation and flow between steps. ### Detailed Analysis #### **Left Column: Structure-Aware Premise** This column details the transformation of a premise statement. * **Step 1: Original Premise** * **Text:** "If Joe eats greasy food, he will feel sick. Given now that Joe feels sick, therefore, Joe must have had greasy food." * **Note:** The words "Joe" (first instance), "he", "Joe" (second instance), "Joe" (third instance), and "had" are highlighted in yellow. * **Step 2: Transformation Process (Arrow Label)** * **Text:** "Coreference resolution + Lemmatization + Stop word removal + Calculating cosine similarity between all word spans, and linking the word spans with a cosine similarity greater than the threshold." * **Step 3: Intermediate Output** * **Text:** "If Coref1 eat greasy food, Coref1 will feel sick. Given now that Coref1 feel sick, therefore, Coref1 must have have greasy food." * **Note:** "Coref1" (all instances), "eat", "feel sick" (first instance), "feel sick" (second instance), and "have" are highlighted in yellow. This shows the result of coreference resolution (replacing "Joe"/"he" with "Coref1") and lemmatization (e.g., "eats" -> "eat", "had" -> "have"). * **Step 4: Final Transformation (Arrow Label)** * **Text:** "Final masked format" * **Step 5: Logic-Aware Premise** * **Text:** "If Person1 [MSK1], Person1 will [MSK2]. Given now that Person1 [MSK2], therefore, Person1 must have [MSK1]." * **Note:** "Person1" (all instances), "[MSK1]" (both instances), and "[MSK2]" (both instances) are highlighted in green. This is the final, abstracted format where specific actions/states are replaced with generic masks ([MSK1], [MSK2]) and the entity is generalized to "Person1". #### **Right Column: Structure-Aware Hypothesis** This column details the transformation of a hypothesis statement that labels the fallacy. * **Step 1: Original Hypothesis** * **Text:** "This is an example of deductive fallacies (affirming the consequent)." * **Note:** The phrase "deductive fallacies (affirming the consequent)" is highlighted in blue. * **Step 2: Transformation Process (Arrow Label)** * **Text:** "Replace the label name with the logical form of the fallacy." * **Step 3: Logic-Aware Hypothesis** * **Text:** "This example matches the following logical form: \"If [MSK1], then [MSK2]\" leads to \"If [MSK2], then [MSK1]\"." * **Note:** The entire logical form string is highlighted in green. This step replaces the specific fallacy name with its abstract logical structure, using the same mask tokens ([MSK1], [MSK2]) as the premise path. #### **Convergence and Classification** * Two grey arrows, one from the "Logic-Aware Premise" box and one from the "Logic-Aware Hypothesis" box, point to the "Pretrained NLI Model" oval. * This indicates that the two standardized, logic-aware texts are fed as a pair into the NLI model. * The model's output is the final classification decision. ### Key Observations 1. **Parallel Transformation:** The process applies analogous transformations to both the premise (the example text) and the hypothesis (the fallacy label), converting them into a shared, abstract language of masks ([MSK1], [MSK2]) and generic entities ("Person1"). 2. **Color-Coding:** The diagram uses color highlights to track elements through transformation: yellow for original content being processed, blue for the original fallacy label, and green for the final masked/logical form elements. 3. **Standardization Goal:** The entire pipeline aims to remove lexical and coreference variability, presenting the NLI model with a pure logical structure to evaluate. 4. **Spatial Layout:** The left (premise) path is more complex, involving multiple NLP steps. The right (hypothesis) path is a single substitution step. Both are given equal weight, feeding centrally into the model. ### Interpretation This diagram outlines a methodology for improving the detection of logical fallacies in text using pretrained NLI models. The core innovation is a **structure-aware preprocessing pipeline** that decouples the logical form from the specific wording. * **What it demonstrates:** It shows how to convert a real-world example of a fallacy ("affirming the consequent") and its definition into a canonical form. By replacing specific actions ("eat greasy food", "feel sick") with masks ([MSK1], [MSK2]) and resolving pronouns, the system forces the model to focus on the flawed logical pattern ("If P then Q; Q; therefore P") rather than the content. * **How elements relate:** The "Premise" path provides the *instance* of reasoning to be judged. The "Hypothesis" path provides the *abstract pattern* of the fallacy. The NLI model is then tasked with determining if the instance matches the pattern—a more straightforward inference problem than detecting the fallacy in raw text. * **Significance:** This approach likely makes fallacy detection more robust and generalizable. A model trained on such paired, logic-aware examples should be better at identifying the same fallacy in different contexts (e.g., "If it rains, the ground is wet. The ground is wet. Therefore, it rained.") because it has learned the abstract structure, not just keyword associations. The "Pretrained NLI Model" is leveraged for its understanding of textual entailment, repurposed here for logical form matching.