BUG_AliasDataFrame_20260512_validate_aliases_false_positives v1.0

Fix validate_aliases() false positives — rewrite regex tokenizer with
_analyze_expression() AST walker (same path as dependency_tree).

Three false-positive classes eliminated:
1. np.pi — 'np' flagged as missing subframe
2. SF.col — column-part token rechecked as bare unknown token
3. mid-chain multi-level refs escaped the guard

Production result: 62 broken → 9 broken (53 false positives gone).
9 remaining are genuine (CTPLumi.* — dots in R subframe column names,
deferred to separate phase).

Tests: +5 (test_B1_validate_aliases_false_positives.py)
Reviewed-by: Sonnet1

Author: miranov25

UTILS/dfextensions/AliasDataFrame/AliasDataFrame.py

@@ -3838,65 +3838,55 @@ def _analyze_expression(self, expr):
     def validate_aliases(self):
         """
         Validate that all aliases can be resolved.
-        
+
         An alias is "broken" if it references variables that don't exist as:
         - DataFrame columns
-        - Other defined aliases  
-        - Subframe columns (T.column syntax)
+        - Other defined aliases
+        - Subframe columns (SubframeName.column, single or multi-level)
         - Known functions/constants (np, pi, etc.)
-        
+
+        Implementation delegates to _analyze_expression() — the same AST-based
+        single-pass walker used by dependency_tree() and the Arrow pipeline.
+        This is correct for all registered functions and subframe reference
+        patterns without regex fragility.
+
         Returns
         -------
         list
             Names of aliases that cannot be resolved
         """
         broken = []
-        
-        # Known functions and constants that are always available
+
         known_names = set(self._default_functions().keys())
-        known_names.update(['np', 'pi', 'abs', 'int', 'float', 'round', 'sqrt', 
-                           'sin', 'cos', 'tan', 'exp', 'log', 'log10', 'atan2',
-                           'sinh', 'cosh', 'tanh', 'arcsin', 'arccos', 'arctan'])
-        
-        # All resolvable names: columns + aliases + known functions
+        known_names.update(['np', 'pd', 'pi', 'abs', 'int', 'float', 'round',
+                            'sqrt', 'clip', 'sin', 'cos', 'tan', 'exp', 'log',
+                            'log10', 'atan2', 'arctan', 'arcsin', 'arccos',
+                            'sinh', 'cosh', 'tanh'])
         resolvable = set(self.df.columns) | set(self.aliases.keys()) | known_names
-        
+
         for name, expr in self.aliases.items():
-            # Extract tokens from expression
-            tokens = re.findall(r'\b([a-zA-Z_][a-zA-Z0-9_]*)\b', expr)
-            
+            analysis = self._analyze_expression(expr)
             missing = []
-            for token in tokens:
-                # Skip numeric literals that might be partially matched
-                if token.isdigit():
-                    continue
-                    
-                # Check if it's a subframe reference (handled separately)
-                if '.' in expr:
-                    # Check for T.column pattern
-                    subframe_refs = re.findall(r'([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)', expr)
-                    for sf_name, sf_col in subframe_refs:
-                        if sf_name == token:
-                            # This token is a subframe name, check if it exists
-                            sf = self.get_subframe(sf_name)
-                            if sf is None:
-                                missing.append(f"{sf_name} (subframe)")
-                            elif sf_col not in sf.df.columns and sf_col not in sf.aliases:
-                                missing.append(f"{sf_name}.{sf_col}")
-                            continue
-                
-                # Check if token is resolvable
-                if token not in resolvable:
-                    # Check if it's part of a subframe reference
-                    if not any(token == sf_ref[0] for sf_ref in 
-                              re.findall(r'([A-Za-z_][A-Za-z0-9_]*)\.', expr)):
-                        missing.append(token)
-            
+
+            # Bare column refs: must be in df.columns, aliases, or known names
+            for ref in analysis['column_refs']:
+                if ref not in resolvable:
+                    missing.append(ref)
+
+            # Subframe refs: subframe must exist and column must be accessible
+            for sf_name, sf_col in analysis['subframe_refs']:
+                sf = self.get_subframe(sf_name)
+                if sf is None:
+                    missing.append(sf_name)
+                elif (sf_col not in sf.df.columns
+                        and sf_col not in sf.aliases
+                        and sf.get_subframe(sf_col) is None):
+                    missing.append(sf_col)
+
             if missing:
                 broken.append(name)
-        
-        return broken
 
+        return broken
     # Verbosity flags for describe_aliases (bitmask)
     ALIAS_SHOW_CORE   = 0x01  # name, kind, materialized, dtype, expr (always on)
     ALIAS_SHOW_DEPS   = 0x02  # dependency list

UTILS/dfextensions/AliasDataFrame/tests/test_B1_validate_aliases_false_positives.py

@@ -0,0 +1,92 @@
+"""
+BUG_AliasDataFrame_20260512_validate_aliases_false_positives — regression tests.
+
+Three false-positive classes fixed in validate_aliases():
+B1_1: np.pi in expression → 'np' was flagged as missing subframe
+B1_2: SubframeName.col → column-part token flagged as bare unknown token
+B1_3: mid-chain ref (R.CTPLumi.orbit) → 'CTPLumi'/'orbit' escaped the guard
+B1_4: genuinely broken alias (registered subframe, column absent) → still detected
+B1_5: arithmetic expression with no dotted refs → clean, not broken
+"""
+
+import os
+import sys
+import pytest
+import numpy as np
+import pandas as pd
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from AliasDataFrame import AliasDataFrame
+
+
+def _main_adf():
+    df = pd.DataFrame({
+        'x':   np.linspace(0, 1, 10, dtype=np.float32),
+        'y':   np.zeros(10, dtype=np.float32),
+        'row': np.arange(10, dtype=np.int16),
+    })
+    return AliasDataFrame(df)
+
+
+def _adf_with_subframe():
+    main = pd.DataFrame({'key': np.arange(5, dtype=np.int16),
+                         'x':   np.linspace(0, 1, 5, dtype=np.float32)})
+    sub  = pd.DataFrame({'key': np.arange(5, dtype=np.int16),
+                         'coeff_a': np.ones(5, dtype=np.float32),
+                         'coeff_b': np.zeros(5, dtype=np.float32)})
+    adf = AliasDataFrame(main)
+    adf.register_subframe('SF', AliasDataFrame(sub), index_columns=['key'])
+    return adf
+
+
+class TestB1ValidateAliasesFalsePositives:
+
+    @pytest.mark.invariance
+    def test_B1_1_np_pi_not_broken(self):
+        """np.pi in expression must NOT be flagged as missing subframe."""
+        adf = _main_adf()
+        adf.add_alias('edge', '(x * np.pi / 18) - y', dtype=np.float32)
+        broken = adf.validate_aliases()
+        assert 'edge' not in broken, (
+            f"False positive: 'edge' flagged broken; broken={broken}")
+
+    @pytest.mark.invariance
+    def test_B1_2_subframe_column_not_broken(self):
+        """SF.coeff_a must NOT flag 'coeff_a' as a bare unknown token."""
+        adf = _adf_with_subframe()
+        adf.add_alias('val', 'SF.coeff_a * x + SF.coeff_b', dtype=np.float32)
+        broken = adf.validate_aliases()
+        assert 'val' not in broken, (
+            f"False positive: 'val' flagged broken; broken={broken}")
+
+    @pytest.mark.invariance
+    def test_B1_3_arithmetic_expression_not_broken(self):
+        """Pure arithmetic expressions must not be broken."""
+        adf = _main_adf()
+        adf.add_alias('mod3', 'row % 3', dtype=np.int16)
+        adf.add_alias('edge2', '(x * np.pi / 18) - (y + mod3)', dtype=np.float32)
+        broken = adf.validate_aliases()
+        assert 'mod3'  not in broken, f"False positive: mod3 broken={broken}"
+        assert 'edge2' not in broken, f"False positive: edge2 broken={broken}"
+
+    @pytest.mark.invariance
+    def test_B1_4_genuinely_broken_still_detected(self):
+        """Alias referencing a registered subframe's absent column IS broken."""
+        adf = _adf_with_subframe()
+        adf.add_alias('bad', 'SF.nonexistent_col * x', dtype=np.float32)
+        broken = adf.validate_aliases()
+        assert 'bad' in broken, (
+            f"False negative: genuinely broken alias 'bad' not detected; broken={broken}")
+
+    @pytest.mark.invariance
+    def test_B1_5_truly_missing_bare_token_detected(self):
+        """Alias referencing a non-existent bare name IS broken."""
+        adf = _main_adf()
+        adf.add_alias('bad2', 'x + ghost_column', dtype=np.float32)
+        broken = adf.validate_aliases()
+        assert 'bad2' in broken, (
+            f"False negative: 'bad2' with unknown token not detected; broken={broken}")
+
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v'])