Fix conference name normalization to preserve critical acronyms (fixes #76) (#81)

## Problem
The normalizer was removing conference acronyms like (CVPR), (NeurIPS), and
(ICCV) from parentheses, making it impossible to match major conferences
against databases like OpenAlex. This caused legitimate conferences to show
as UNKNOWN instead of LEGITIMATE.

## Solution

### 1. Extract acronyms as aliases (normalizer.py)
- Added _extract_acronyms() method to identify conference/journal acronyms
- Uses heuristics: primarily uppercase (≥50%), 2-20 chars, starts uppercase
- Filters out metadata keywords (ISSN, online, invited, etc.)
- Extracts acronyms like CVPR, NeurIPS, ICCV before text cleaning
- Adds extracted acronyms to aliases list for backend matching

### 2. Enable alias fallback in OpenAlex backend (openalex_analyzer.py)
- If normalized name not found, iterates through aliases
- Stops at first successful match
- Logs which alias was used for debugging
- Includes tried aliases in NOT_FOUND response data

## Results
- "IEEE Conference on CVPR (CVPR)" → LEGITIMATE (was UNKNOWN)
- "International Conference on Computer Vision (ICCV)" → LEGITIMATE (was UNKNOWN)
- All 244 unit tests pass
- Mypy type checking passes

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

Author: coding-ai-assistant[bot]

src/aletheia_probe/backends/openalex_analyzer.py

@@ -59,6 +59,21 @@ async def _query_api(self, query_input: QueryInput) -> BackendResult:
                     journal_name=journal_name, issn=issn, eissn=eissn
                 )
 
+                # If not found with normalized name, try aliases (especially acronyms)
+                if not openalex_data and query_input.aliases:
+                    self.detail_logger.info(
+                        f"OpenAlex: Normalized name '{journal_name}' not found, trying {len(query_input.aliases)} alias(es)"
+                    )
+                    for alias in query_input.aliases:
+                        openalex_data = await client.enrich_journal_data(
+                            journal_name=alias, issn=issn, eissn=eissn
+                        )
+                        if openalex_data:
+                            self.detail_logger.info(
+                                f"OpenAlex: Found match using alias '{alias}'"
+                            )
+                            break
+
                 response_time = time.time() - start_time
 
                 if not openalex_data:
@@ -72,6 +87,7 @@ async def _query_api(self, query_input: QueryInput) -> BackendResult:
                             "searched_for": journal_name,
                             "issn": issn,
                             "eissn": eissn,
+                            "aliases_tried": query_input.aliases,
                         },
                         sources=["https://api.openalex.org"],
                         error_message=None,

src/aletheia_probe/normalizer.py

@@ -119,6 +119,9 @@ def normalize(self, raw_input: str) -> QueryInput:
         # Extract identifiers first
         identifiers = self._extract_identifiers(raw_input)
 
+        # Extract conference/journal acronyms from parentheses before cleaning
+        extracted_acronyms = self._extract_acronyms(raw_input)
+
         # Clean and normalize the text
         normalized = self._clean_text(raw_input)
         normalized = self._expand_abbreviations(normalized)
@@ -127,6 +130,18 @@ def normalize(self, raw_input: str) -> QueryInput:
         # Generate aliases
         aliases = self._generate_aliases(normalized)
 
+        # Add extracted acronyms to aliases for better matching
+        aliases.extend(extracted_acronyms)
+
+        # Remove duplicates while preserving order
+        seen: set[str] = set()
+        unique_aliases: list[str] = []
+        for alias in aliases:
+            if alias not in seen:
+                seen.add(alias)
+                unique_aliases.append(alias)
+        aliases = unique_aliases
+
         return QueryInput(
             raw_input=raw_input.strip(),
             normalized_name=normalized,
@@ -152,6 +167,69 @@ def _extract_identifiers(self, text: str) -> dict[str, str]:
 
         return identifiers
 
+    def _extract_acronyms(self, text: str) -> list[str]:
+        """Extract conference/journal acronyms from parentheses for use as aliases.
+
+        Conference acronyms are typically uppercase letters, possibly with numbers,
+        and appear in parentheses (e.g., CVPR, NeurIPS, ICCV, 3DV).
+
+        Examples:
+            "IEEE Conference on Computer Vision (CVPR)" -> ["CVPR"]
+            "Neural Information Processing Systems (NeurIPS)" -> ["NeurIPS"]
+            "Conference (ISSN: 1234-5678)" -> []  # Not an acronym
+
+        Args:
+            text: Input text that may contain parenthesized acronyms
+
+        Returns:
+            List of extracted acronyms
+        """
+        acronyms = []
+
+        # Find all content within parentheses
+        pattern = r"\(([^)]+)\)"
+        matches = re.findall(pattern, text)
+
+        for content in matches:
+            content = content.strip()
+
+            # Skip if contains certain keywords that indicate metadata, not acronyms
+            skip_keywords = [
+                "issn",
+                "isbn",
+                "doi",
+                "online",
+                "print",
+                "invited",
+                "accepted",
+                "to appear",
+            ]
+            if any(keyword in content.lower() for keyword in skip_keywords):
+                continue
+
+            # Check if content looks like a conference/journal acronym:
+            # - Primarily uppercase letters (allow some lowercase for mixed cases like NeurIPS)
+            # - May contain numbers (e.g., 3DV, CVPR'23)
+            # - May contain apostrophes for year indicators (e.g., CVPR'23)
+            # - May contain hyphens (e.g., AAAI-23)
+            # - Typically short (2-20 characters)
+            # - Must start with uppercase letter
+            # - No spaces, colons, or special punctuation
+
+            # Pattern: starts with uppercase, contains mostly uppercase letters/numbers,
+            # may have apostrophes, hyphens, or few lowercase letters
+            if re.match(r"^[A-Z][A-Za-z0-9'\-]{1,19}$", content):
+                # Additional check: should have a good proportion of uppercase letters
+                # to avoid catching things like "(Online)" or "(Invited)"
+                # Use 50% threshold to catch "NeurIPS" (57%) while excluding "Online" (17%)
+                uppercase_count = sum(1 for c in content if c.isupper())
+                total_alpha = sum(1 for c in content if c.isalpha())
+
+                if total_alpha > 0 and (uppercase_count / total_alpha) >= 0.5:
+                    acronyms.append(content)
+
+        return acronyms
+
     def _clean_text(self, text: str) -> str:
         """Clean and normalize text using regex patterns."""
         # Remove identifiers from text for name normalization