🤖 AI

Technical Report -- A Context-Sensitive Multi-Level Similarity Framework for First-Order Logic Arguments: An Axiomatic Study

This paper introduces a comprehensive, axiomatic framework for measuring similarity in First-Order Logic arguments by proposing a four-level parametric model that integrates syntax-sensitive language models with contextual weights to address the limitations of existing propositional approaches.

Original authors: Victor David, Jérôme Delobelle, Jean-Guy Mailly

Published 2026-04-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Victor David, Jérôme Delobelle, Jean-Guy Mailly

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a judge in a debate club. Two students, Alice and Bob, stand up to argue their points. Your job isn't just to decide who wins; you need to figure out how similar their arguments are. Are they saying the exact same thing? Are they talking past each other? Or are they just slightly different versions of the same idea?

For a long time, computers were good at comparing simple arguments (like "It's raining" vs. "It's drizzling"). But when arguments get complex—using variables, relationships, and deep logic (like "Every dog loves some bone")—computers got confused. They either missed the nuance or got overwhelmed by the math.

This paper introduces a new, super-smart framework to measure how similar complex arguments are. Think of it as a "Multi-Level Similarity Telescope" that zooms in and out to see the big picture and the tiny details.

Here is how it works, broken down into simple concepts:

1. The Problem: The "Translation" Gap

Imagine you have two sentences:

Sentence A: "A dog is teasing a monkey at the zoo."
Sentence B: "A monkey is teasing a dog at the zoo."

To a human, these are very different. In Sentence A, the dog is the aggressor. In Sentence B, the monkey is. But to a basic computer, they look almost identical because they use the same words ("dog," "monkey," "teasing," "zoo").

The authors say: "We need a system that understands structure (who is doing what to whom) AND meaning (how important 'teasing' is compared to 'zoo')."

2. The Solution: The Four-Level Telescope

The authors built a framework that breaks arguments down into four layers, like peeling an onion or looking at a building from different angles:

Level 1: The Bricks (Predicates & Terms): This is the vocabulary. Is "Dog" similar to "Puppy"? Is "Tease" similar to "Play"? The system uses AI (like a smart translator) to know that "Dog" and "Puppy" are close, but "Dog" and "Banana" are not.
Level 2: The Mortar (Literals): This connects the bricks. It looks at the whole phrase "Dog teases Monkey." It checks if the roles match up.
Level 3: The Rooms (Clauses): A clause is a full thought or a rule. The system compares entire rooms of the argument.
Level 4: The Building (Full Arguments): Finally, it looks at the whole structure: the premises (the evidence) and the conclusion (the claim).

3. The Secret Sauce: "Contextual Weights"

This is the most creative part. Imagine you are comparing two recipes.

Recipe A: "Add a pinch of salt and 2 cups of flour."
Recipe B: "Add a pinch of salt and 2 cups of glitter."

If you just count the words, they look similar. But if you are baking a cake, flour is 99% important, and salt is 1%. Glitter is a disaster.

The authors' framework allows you to assign "Importance Weights."

In a legal argument, the conclusion might be the most important part.
In a scientific argument, the data (premises) might matter more.
In our "Dog vs. Monkey" example, the action "Tease" is the most important part of the sentence. The location "Zoo" is less important.

The system calculates the similarity by saying: "Okay, the locations match perfectly (100%), but the main action is reversed (50% match). Since the action is 90% important and the location is only 10% important, the total similarity is about 60%."

This explains why the computer knows that "Dog teases Monkey" is not the same as "Monkey teases Dog," even though they use the same words.

4. The "Axiomatic" Rules (The Rulebook)

The authors didn't just guess; they wrote a strict rulebook (called an Axiomatic Foundation) to ensure the system behaves logically.

The Mirror Rule: If Argument A is similar to B, then B must be similar to A.
The Identity Rule: An argument is always 100% similar to itself.
The "Nothingness" Rule: If two arguments share absolutely no common words or concepts, their similarity must be zero.
The "Addition" Rule: If you add a new piece of information that is totally unrelated to the other argument, the similarity score shouldn't magically go up.

5. Why Does This Matter?

This isn't just for math nerds. This framework helps computers:

Summarize Debates: It can tell a judge, "These two lawyers are arguing the same point but using different words," or "These two are actually fighting about two totally different things."
Decode Hidden Meanings: Sometimes people leave out parts of an argument (like saying "He's a dog, so he's loyal" without saying "Dogs are loyal"). This system can fill in the blanks by finding similar arguments.
Explain AI Decisions: Instead of a computer saying "I think this is similar," it can say, "I think this is 60% similar because the main actions match, but the subjects are swapped."

The Bottom Line

The authors have built a translator and a judge rolled into one. It takes complex, logical arguments, breaks them down into their smallest parts, weighs the importance of each part based on the context, and gives a clear, explainable score of how similar they are.

It's like having a super-intelligent librarian who doesn't just count how many words two books share, but actually reads the story, understands the characters' roles, and tells you exactly how much the plots overlap.

1. Problem Statement

Formal argumentation relies on assessing the acceptability of arguments within a graph structure. A critical challenge in this domain is argument similarity: determining how much two arguments resemble each other to avoid redundancy in aggregation (e.g., in gradual semantics) or to evaluate the quality of enthymeme decoding (reconstructing incomplete arguments).

While existing frameworks address similarity in Propositional Logic, they struggle in the richer setting of First-Order Logic (FOL) due to:

Syntactic Proximity: Difficulty in handling variable instantiation and structural variations.
Scalability: The combinatorial explosion caused by full variable instantiation.
Lack of Context: Existing methods often treat all logical symbols equally, ignoring the semantic importance of specific predicates or terms in natural language contexts.

The paper aims to bridge this gap by proposing a framework that handles FOL arguments with structural rigor, semantic nuance, and contextual weighting.

2. Methodology

The authors propose a four-level parametric similarity model built upon a compiled CNF (Conjunctive Normal Form) representation of FOL arguments. The methodology consists of three main stages:

A. Logical Transformation & Representation

Argument Definition: An argument is defined as a pair $\langle \Phi, \alpha \rangle$ where $\Phi$ is a minimal consistent set of premises supporting claim $\alpha$ .
CNF Compilation: To handle FOL complexity, arguments are transformed into a compiled CNF form ( $\text{CNF}(\Phi)$ ). This involves Skolemization to eliminate existential quantifiers and standard normalization. This approximation preserves satisfiability and structure while avoiding the infeasibility of full grounding in open domains.
Bijective Equivalence: Arguments are considered equivalent if there is a bijection between their support and claim components that preserves logical equivalence.

B. Multi-Level Similarity Architecture

The framework computes similarity hierarchically, from atomic elements to full arguments:

Predicate & Term Level ( $sim_P$ ): Measures similarity between predicates (e.g., Tease) and constants/variables (e.g., dog). This can be syntax-sensitive (using language models like SBERT) or syntax-independent (exact matching).
Literal Level ( $sim_L$ ): Combines predicate and term similarities. It supports both ordered (positional) and unordered (best-match) comparisons, controlled by a parameter $\lambda$ .
Clause Level ( $sim_C$ ): Uses a fuzzy Tversky measure to aggregate literal similarities within a clause. This allows for partial matching and handles clauses of different lengths.
Set-of-Clauses Level ( $sim_S$ ): Aggregates clause similarities using a weighted best-match strategy. Clauses are matched to their best counterpart in the opposing set, weighted by their contextual importance.

C. Context-Sensitive Weighting

A key innovation is the introduction of contextual weights ( $w_p, w_c$ ) assigned to predicates, terms, and clauses.

Dynamic Importance: Weights reflect the semantic relevance of elements in a specific context (e.g., the predicate Tease might be more critical than AtLocation in a specific argument).
Aggregation: These weights are integrated into the similarity calculations, ensuring that highly important but slightly dissimilar components have a larger impact on the final score than trivial, perfectly matching components.

D. Final Argument Similarity

The similarity between two arguments $A$ and $B$ is computed as a weighted sum of the similarity of their supports ( $S$ ) and claims ( $C$ ):
$sim_{Arg}(A, B) = \eta \times sim_S(S(A^c), S(B^c)) + (1 - \eta) \times sim_S(C(A^c), C(B^c))$
where $\eta$ balances the importance of premises vs. conclusions.

3. Key Contributions

Extended Axiomatic Foundation: The paper defines a comprehensive set of 14 principles (axioms) for argument similarity, including:
- Maximality, Symmetry, Substitution: Standard properties.
- Syntax Independence: (Optional, depending on model choice).
- Minimality & Non-Zero: Ensuring similarity propagates from base levels.
- Monotony & Reinforcement: Formalizing how adding information affects similarity scores.
  The authors prove that their framework satisfies these principles under specific conditions.
Two Model Families:
- Syntax-Sensitive ( $M_{sb}$ ): Uses language models (e.g., SBERT) for $sim_P$ , capturing semantic nuances (e.g., "house" $\approx$ "apartment").
- Syntax-Independent ( $M_{eq}$ ): Uses exact matching, suitable for strict logical equivalence.
  Both families integrate the contextual weighting mechanism.
Hybrid Pipeline: A three-stage pipeline combining:
- Symbolic transformation (Text $\to$ FOL $\to$ CNF).
- Contextual weight assignment (manual or learned).
- Structured similarity computation (Multi-level aggregation).

4. Results and Evaluation

Case Study (STSb Dataset): The framework was tested on natural language sentences converted to FOL.
- Scenario: Comparing "A dog is teasing a monkey" vs. "A monkey is teasing a dog."
- Performance: The framework achieved a similarity score of 0.628, closely matching the human average of 0.630.
- Comparison:
  - SBERT gave 0.985 (too high, ignores role reversal).
  - S3BERT gave 0.990 (high, lacks clear explanation).
  - ChatGPT-4o gave 0.400 (too low, lacks structure).
- Interpretability: The framework provided a transparent breakdown, showing that while location clauses matched perfectly (low weight), the role reversal in the Tease predicate (high weight) significantly reduced the score.
Argument Comparison: In a scenario comparing three arguments about animal behavior, the framework demonstrated that the similarity ranking between arguments could shift based on the weighting parameter $\eta$ (premises vs. claims), illustrating its flexibility for different reasoning tasks (e.g., debate vs. enthymeme decoding).
Theoretical Guarantees: Theorems 1–10 formally prove that the proposed models satisfy the defined axiomatic principles (e.g., Maximality, Symmetry, Monotony), with the exception of Syntax Independence for the SBERT-based model (by design) and Non-Zero in specific edge cases.

5. Significance

Bridging Logic and NLP: This work is a significant step toward applying formal argumentation theory to natural language processing. It leverages the structure of FOL to provide explainable AI (XAI) while using language models to handle semantic ambiguity.
Explainability: Unlike "black-box" embedding models, this framework offers symbolic decomposition. Users can trace exactly which predicates, terms, or clauses drove the similarity score, making it highly valuable for decision support and legal/medical argumentation.
Scalability in Open Domains: By using Skolemization and approximating variables as constants, the framework avoids the computational intractability of full FOL instantiation, making it applicable to real-world, open-domain scenarios.
Context Awareness: The introduction of contextual weighting addresses a major limitation of traditional logical similarity, where all symbols are treated equally. This allows the system to adapt to the specific nuances of a debate or a specific domain.

In conclusion, the paper presents a theoretically grounded, practically applicable framework that enhances the assessment of argument similarity in First-Order Logic, offering a robust alternative to purely statistical or purely syntactic approaches.