🤖 AI

Hybrid-Code v2: Zero-Hallucination Clinical ICD-10 Coding via Neuro-Symbolic Verification and Automated Knowledge Base Expansion

Hybrid-Code v2 is a neuro-symbolic framework that achieves zero Type-I hallucination in clinical ICD-10 coding by integrating neural candidate generation with a symbolic verification layer and automated knowledge base expansion, thereby delivering high precision and coverage without the safety risks of purely neural approaches.

Original authors: Yunguo Yu

Published 2026-03-24

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Yunguo Yu

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 librarian trying to organize a massive, chaotic library of patient stories. Every story needs to be tagged with a specific, official code (like a barcode) so the hospital knows how to bill insurance and track diseases. This is called ICD-10 coding.

The problem is that there are over 70,000 possible codes, and the rules for using them are incredibly strict. If you tag a story with the wrong code, it's like putting a "Poison" label on a jar of honey. It can cause billing fraud, confuse doctors, or even endanger patients.

For a long time, we've had two ways to do this tagging:

The "Human Rulebook" (Rule-Based Systems): Imagine a librarian who only uses a tiny, strict checklist. They will never make a mistake because they only pick codes they are 100% sure of. But because the checklist is so small, they miss 55% of the books. They can't tag complex stories.
The "Super-Intelligent Robot" (Neural AI): Imagine a robot that has read every book in the library. It is amazing at finding the right tags for complex stories. But, the robot has a bad habit: sometimes, when it's not sure, it hallucinates. It invents a fake code that sounds real but doesn't exist (like a barcode for "Dragon Disease"). In a hospital, making up a code is dangerous.

Enter "Hybrid-Code v2": The Smart Librarian with a Safety Net.

This paper introduces a new system that combines the best of both worlds. Think of it as a two-step assembly line:

Step 1: The Creative Generator (The Neural Part)

First, a smart AI (like the robot) reads the patient's story and suggests a list of possible codes. It's fast, flexible, and good at understanding complex language.

The Risk: Sometimes, this AI might suggest a code that doesn't actually exist in the official library.

Step 2: The Strict Gatekeeper (The Symbolic Part)

Before any code is ever written down, it must pass through a "Gatekeeper." This isn't a brain; it's a rigid, unbreakable rulebook. The Gatekeeper checks the AI's suggestions against the official, real ICD-10 codebook.

The Check: "Does this code actually exist?" "Is the patient actually sick with this (not just 'ruled out' or 'history of')?" "Do these two codes fight each other?"
The Result: If the AI suggested a fake code, the Gatekeeper slams the door. Zero fake codes get through.

The Magic Trick: Teaching the Gatekeeper to Grow

The old problem with rulebooks was that they were too small and took years for humans to write.
Hybrid-Code v2 has a secret weapon: Automated Expansion.
Imagine the Gatekeeper has a robot assistant that reads thousands of new patient stories, finds patterns humans missed, and suggests new rules to add to the Gatekeeper's book.

A human expert then quickly double-checks these new rules.
If they are good, they get added.
Now the Gatekeeper knows more codes without needing a human to write every single rule from scratch.

The Results: The Perfect Balance

The researchers tested this system on 5,000 patient stories. Here is what happened:

The "Fake Code" Problem: The smart robots (AI models) made up fake codes 6% to 18% of the time. The Hybrid-Code system made zero fake codes. It was perfect at safety.
The "Missing Code" Problem: The old rulebooks missed half the stories. The Hybrid-Code system found the right codes for 85% of the stories, which is almost as good as the smart robots.
The "Accuracy" Problem: When it did pick a code, it was right 88% of the time.

Why This Matters

Think of it like a self-driving car.

Old AI: Drives fast and handles traffic well, but sometimes it hallucinates a stop sign that isn't there and crashes.
Old Rules: Drives very slowly and safely, but it can't handle complex intersections, so it gets stuck.
Hybrid-Code: It drives fast and handles complex traffic, but it has an unbreakable safety belt that physically prevents it from driving off a cliff.

In short: This paper proves you don't have to choose between a smart system and a safe system. By adding a "fact-checker" layer to an AI, you can get the speed and smarts of a robot with the safety guarantees of a strict rulebook. This is a huge step toward trusting AI in hospitals.

1. Problem Statement

Automated clinical coding (translating medical narratives into ICD-10 codes) faces a critical trade-off between coverage/precision and safety.

Neural Approaches (e.g., BERT, LLMs): Achieve high coverage and precision but suffer from Type I hallucinations (generating syntactically invalid or non-existent ICD-10 codes). In safety-critical healthcare settings, even a small rate of invalid codes (6–18% in baselines) poses unacceptable risks for patient safety and billing fraud.
Rule-Based Systems: Guarantee zero hallucinations by using explicit rules but suffer from low coverage and scalability issues because they rely on expensive, manual knowledge base (KB) curation. They often fail to capture implicit clinical context or evolving medical knowledge.

The paper addresses the need for a system that achieves zero Type I hallucination by construction while maintaining competitive coverage and precision, without relying on prohibitive manual curation.

2. Methodology: Hybrid-Code v2

The authors propose a Neuro-Symbolic Framework that integrates neural pattern matching with a symbolic verification layer. The system operates in two distinct phases:

Phase 1: Automated Knowledge Base (KB) Expansion

To overcome the scalability limits of rule-based systems, the system automatically expands its KB using distant supervision from unlabeled clinical text.

Pattern Extraction: Uses lexical patterns (e.g., "ICD-10: CODE") and neural embeddings (BioMistral-7B) to identify associations between clinical concepts and ICD-10 codes.
Multi-Layer Verification: Before a candidate (concept, code) pair is added to the KB, it must pass five sequential verification layers:
1. Format: Ensures the code exists in the official ICD-10-CM codebook.
2. Evidence: Verifies explicit textual evidence links the concept to the code.
3. Negation: Detects and rejects codes associated with negated phrases (e.g., "ruled out").
4. Temporal: Ensures the condition is current, not historical or future.
5. Exclusion: Checks against ICD-10 exclusion rules (e.g., Excludes1).
Integration: Only verified pairs are integrated into the KB, ensuring the KB itself is free of syntactic errors.

Phase 2: Runtime Coding

When processing a new clinical document:

Candidate Generation: Generates candidate codes via two paths:
- KB-Based: Retrieves codes based on extracted entities from the expanded KB.
- Neural: Uses a zero-shot BioMistral-7B model to propose codes directly from the text.
Symbolic Verification: All candidates undergo the same 5-layer verification process used during KB expansion.
Output: Only codes passing all layers are assigned. This architectural constraint guarantees Zero Type I Hallucination.

3. Key Contributions

Zero Type-I Hallucination Guarantee: The system provides a formal proof (Proposition 1) that it never assigns a code outside the official ICD-10 codebook ( $C_{ICD-10}$ ), eliminating syntactic invalidity by construction.
Automated KB Expansion: Introduces a mechanism to scale the KB from 1,000 to 1,500 codes (proof of concept) using distant supervision, achieving a 40% coverage improvement over a minimal 38-rule baseline without per-code manual annotation.
Hybrid Architecture: Successfully balances the flexibility of neural methods (for coverage and pattern recognition) with the rigor of symbolic methods (for safety and interpretability).
Comprehensive Evaluation: Establishes a rigorous evaluation framework including statistical significance testing, ablation studies, and error analysis across 5,000 test cases.

4. Experimental Results

Evaluated on the MIMIC-III dataset (5,000 test cases) against ClinicalBERT, BioBERT, a Rule-Based system, and GPT-4 (zero-shot).

Metric	Hybrid-Code v2	ClinicalBERT	BioBERT	Rule-Based	GPT-4 (T=0.0)
Coverage	85%	78%	80%	45%	79%
Precision	88%	85%	87%	40%	92%
Recall	82%	72%	74%	56%	76%
F1 Score	86%	78%	80%	47%	83%
Type I Hallucination	0%	8%	6%	0%	9%

Safety: Hybrid-Code is the only system to achieve 0% Type I hallucination while maintaining high coverage. Neural baselines and GPT-4 (even at temperature 0.0) generated invalid codes (6–18%).
Coverage: Outperformed the rule-based baseline by +40% and matched or exceeded neural baselines.
Statistical Significance: All pairwise comparisons against Hybrid-Code were statistically significant ( $p < 0.001$ ).
Ablation Study: Confirmed that KB Expansion contributed the most to coverage (+15%), while Negation Detection was crucial for precision (+8%).
KB Quality: A manual audit of 200 newly added KB entries showed 82% precision at full specificity.

5. Significance and Impact

Safety-Critical AI: Demonstrates that neuro-symbolic verification can enforce hard safety constraints (zero invalid outputs) in medical AI without sacrificing the performance benefits of deep learning. This offers a replicable design pattern for other high-stakes domains.
Scalability: Solves the "curation bottleneck" of rule-based systems. The automated expansion mechanism allows KBs to grow with new medical data, reducing reliance on scarce expert curation.
Clinical Utility: With 85% coverage and 88% precision, the system is viable for clinical decision support (pre-populating codes for human review), potentially reducing coder workload and error rates.
Limitations & Future Work: The system currently addresses Type I (syntactic) hallucinations but not Type II (semantic) hallucinations (valid codes assigned to wrong patients), which remains a challenge (12% false positive rate). Future work includes scaling to the full 78,000-code ICD-10-CM book, cross-dataset generalization, and handling complex ICD-10 sequencing rules.

In conclusion, Hybrid-Code v2 represents a significant step forward in trustworthy medical AI, proving that architectural constraints can eliminate specific classes of errors that training alone cannot fix.