feat: Implement case-insensitive venue name matching (fixes #73) (#84)

Add venue assessment caching with case-insensitive matching to prevent
duplicate backend queries and inconsistent results for venues differing
only in capitalization.

Changes:
- Add venue_assessment_cache dict in batch_assessor using lowercase
  normalized names as keys
- Check cache before querying backends to reuse results for case variants
- Add comprehensive test for case-insensitive normalization behavior

Benefits:
- Eliminates duplicate backend queries for same venue with different cases
- Ensures consistent assessment results across case variations
- Reduces computational overhead and API calls
- Improves statistics accuracy (no duplicate venue counting)

Test Coverage:
- New test validates different case variations normalize to same key
- All 270 existing tests pass
- Code quality checks pass (ruff, mypy)

Co-authored-by: florath-ai-assistant[bot] <Andreas.Florath@telekom.de>

Author: coding-ai-assistant[bot]

src/aletheia_probe/batch_assessor.py

@@ -114,6 +114,9 @@ async def assess_bibtex_file(
         # Assess each journal
         assessment_results: list[tuple[BibtexEntry, AssessmentResult]] = []
 
+        # Cache for venue assessments using case-insensitive normalized names
+        venue_assessment_cache: dict[str, AssessmentResult] = {}
+
         for i, entry in enumerate(bibtex_entries, 1):
             status_logger.info(
                 f"[{i}/{len(bibtex_entries)}] Assessing: {entry.journal_name}"
@@ -150,12 +153,29 @@ async def assess_bibtex_file(
                     f"Normalized journal name: {query_input.normalized_name}"
                 )
 
-                # Assess the journal
-                assessment = await query_dispatcher.assess_journal(query_input)
-                detail_logger.debug(
-                    f"Assessment result: {assessment.assessment}, confidence: {assessment.confidence:.2f}"
+                # Create a cache key using lowercase normalized name for case-insensitive matching
+                cache_key = (
+                    query_input.normalized_name.lower()
+                    if query_input.normalized_name
+                    else entry.journal_name.lower()
                 )
 
+                # Check if we've already assessed this venue (case-insensitive)
+                if cache_key in venue_assessment_cache:
+                    assessment = venue_assessment_cache[cache_key]
+                    detail_logger.debug(
+                        f"Using cached assessment for '{entry.journal_name}' (matches '{cache_key}')"
+                    )
+                    status_logger.info("    → Using cached result for case variant")
+                else:
+                    # Assess the journal
+                    assessment = await query_dispatcher.assess_journal(query_input)
+                    detail_logger.debug(
+                        f"Assessment result: {assessment.assessment}, confidence: {assessment.confidence:.2f}"
+                    )
+                    # Cache the assessment for future case variants
+                    venue_assessment_cache[cache_key] = assessment
+
                 # Store the result
                 assessment_results.append((entry, assessment))
 

tests/unit/test_normalizer.py

@@ -265,3 +265,50 @@ def test_acronym_preservation(self):
         # Test mixed case input
         result4 = normalizer.normalize("IeEe CoNfErEnCe")
         assert result4.normalized_name == "IEEE Conference"
+
+    def test_case_insensitive_normalization_produces_same_lowercase_key(self):
+        """Test that different case variations normalize to the same lowercase key.
+
+        This test verifies that venue names differing only in case will produce
+        the same cache key when lowercased, enabling case-insensitive matching.
+        """
+        normalizer = InputNormalizer()
+
+        # Test conference names with different cases
+        result1 = normalizer.normalize("International Conference on Machine Learning")
+        result2 = normalizer.normalize("International conference on machine learning")
+        result3 = normalizer.normalize("INTERNATIONAL CONFERENCE ON MACHINE LEARNING")
+
+        # After normalization, the lowercase versions should be identical
+        assert result1.normalized_name.lower() == result2.normalized_name.lower()
+        assert result1.normalized_name.lower() == result3.normalized_name.lower()
+
+        # Test journal names with different cases
+        result4 = normalizer.normalize(
+            "IEEE Transactions on Neural Networks and Learning Systems"
+        )
+        result5 = normalizer.normalize(
+            "IEEE transactions on neural networks and learning systems"
+        )
+        result6 = normalizer.normalize(
+            "ieee TRANSACTIONS on NEURAL networks AND learning SYSTEMS"
+        )
+
+        # After normalization, the lowercase versions should be identical
+        assert result4.normalized_name.lower() == result5.normalized_name.lower()
+        assert result4.normalized_name.lower() == result6.normalized_name.lower()
+
+        # Test with conference full names
+        result7 = normalizer.normalize(
+            "Advances in Neural Information Processing Systems"
+        )
+        result8 = normalizer.normalize(
+            "Advances in neural information processing systems"
+        )
+        result9 = normalizer.normalize(
+            "ADVANCES IN NEURAL INFORMATION PROCESSING SYSTEMS"
+        )
+
+        # After normalization, the lowercase versions should be identical
+        assert result7.normalized_name.lower() == result8.normalized_name.lower()
+        assert result7.normalized_name.lower() == result9.normalized_name.lower()