kitan-liyah/legal_eval

Negation Blind Spots in Legal AI: A Hands-On Evaluation

1. The Blind Spot: Why "Not" Changes Everything

While building a legal AI copilot, I kept running into the same dangerous failure mode: if a user asked, "Is the vendor liable for damages?", the system would confidently retrieve and rank a clause stating the vendor is not liable.

To a standard AI retriever, "liable" and "not liable" look almost identical. They share the same keywords and occupy the same space in the model's memory. In a general search engine, this is a minor relevance issue. In a legal contract, it is a catastrophic liability inversion that actively misleads the user.

I initially assumed that using a domain-specific model (like Legal-BERT) would solve this. But as I dug deeper, I realized that knowing legal vocabulary is not the same as understanding legal logic. A model can recognize that "indemnification" is an important legal concept while being completely blind to the word "not" that reverses its meaning. Standard benchmarks rarely test this specific, high-stakes logical failure.

2. My Systematic Evaluation

To prove this wasn't just a one-off bug, I designed a targeted evaluation of Qwen/Qwen2.5-3B-Instruct (a frontier open-weight model under 6B parameters), running it on a Modal T4 GPU.

The Dataset (Hand-Curated, Not Generated): I didn't just write a script to slap the word "not" onto random sentences. I manually curated 78 realistic legal clause pairs. I specifically designed them to test tricky failure modes: subtle modal shifts (e.g., changing "shall" to "is under no obligation to"), lexical antonyms ("expressly covers" vs. "expressly excludes"), and complex double negatives. Every pair in the dataset includes a the specific logical trap being tested.

The Test: I forced the model to classify the actual legal effect of each clause, answering strictly with "Obligation" or "Exemption". I then checked if it correctly identified the original clause as an Obligation AND the negated version as an Exemption.

The Results:

• Pairwise Accuracy: 47.4% (It failed on 41 out of 78 pairs).

What the Failures Taught Me (Error Analysis): By manually reading through the 41 failures, a clear pattern emerged:

1. Keyword Overpowering: The model frequently labeled both the original and negated clauses as "Obligation." For example, when given the clause "The party is expressly relieved of the obligation to maintain quality systems," the model latched onto the high-value tokens "maintain quality systems" and completely ignored the logical operator "expressly relieved of."
2. Double-Negative Breakdown: When a clause used complex phrasing (e.g., flipping "None of the parties shall..." to "The parties are expressly permitted to..."), the model's logic broke down, often misclassifying the explicit permission as a strict obligation.

This experiment confirmed my initial suspicion: zero-shot models encode legal vocabulary, but they do not reliably encode legal logic.

3. A Practical Path Forward

We don't necessarily need massive, multi-billion parameter models to fix this. Based on my findings and recent research in negation-aware retrieval, I propose a targeted, data-efficient fine-tuning approach:

1. Synthetic Hard Negatives: Use a capable open-weight model (like Qwen2.5-7B) to generate realistic, polarity-inverted versions of real contract clauses (e.g., from the CUAD dataset).
2. Strict Quality Filtering: Automatically filter out bad generations by checking that the new clause is neither a trivial copy nor a complete hallucination (e.g., using Jaccard similarity bounds between 0.70 and 0.98).
3. Cross-Encoder Fine-Tuning: Train a small, fast reranker (like MiniLM or Legal-BERT) specifically on these binary "obligation vs. exemption" pairs, paired with realistic user queries.

Recent studies show this specific approach saturates in performance with as few as 1,500 training pairs. This makes it a highly practical, low-cost fix for specialized legal domains where large, human-annotated datasets don't exist, directly solving the liability inversion problem at the retrieval layer.

---

Artifacts Included in this Repo:

• legal_negation_dataset.json: The 78 hand-curated clause pairs, complete with my manual category and human_notes annotations.
• negation_eval_results.csv: The raw output log from my Modal run, showing the exact 47.4% accuracy and the specific failure cases.
• evaluation_script.py: The reproducible Python script I used to run the inference.