Phase 13.9.Fix1: Polynomial function persistence through schema export/import

export_schema_v2 now includes registered_functions.
apply_schema calls _reconstruct_registered_functions() which rebuilds
polynomials from PolynomialSpec + subframe coefficients.
Evaluators skipped by design (GBAI owns persistence).

8 new tests (schema roundtrip, reconstruction, evaluator skip, invariance).
1440 passed, 6 failed (pre-existing).

Author: miranov25

UTILS/dfextensions/AliasDataFrame/AliasDataFrame.py

@@ -8424,6 +8424,11 @@ def export_schema_v2(self, include_precision_stats=False, include_state=True,
         if hasattr(self, '_fit_metadata') and self._fit_metadata:
             result['fit_metadata'] = copy.deepcopy(self._fit_metadata)
 
+        # 7. Registered functions (Phase 13.9 Fix1)
+        reg_funcs = self._schema.get('registered_functions')
+        if reg_funcs:
+            result['registered_functions'] = copy.deepcopy(reg_funcs)
+        
         return result
 
     def export_definition_schema(self, **kwargs):
@@ -8713,6 +8718,69 @@ def apply_schema(self, schema, validate=True, warn_missing=True):
                     UserWarning
                 )
             self._fit_metadata = copy.deepcopy(schema['fit_metadata'])
+        
+        # Restore registered functions if present (Phase 13.9 Fix1)
+        # Polynomials are reconstructed automatically if subframes are registered.
+        # Evaluators require manual re-registration (by design).
+        if 'registered_functions' in schema:
+            self._schema['registered_functions'] = copy.deepcopy(schema['registered_functions'])
+            self._reconstruct_registered_functions()
+
+    def _reconstruct_registered_functions(self):
+        """
+        Reconstruct polynomial functions from schema after load.
+        
+        Requires subframes to be already registered. Evaluator functions
+        are NOT reconstructed (by design — GBAI owns evaluator persistence).
+        
+        Phase 13.9 Fix1: Polynomial persistence through export/import.
+        """
+        from dfextensions.AliasDataFrame.PolynomialSpec import PolynomialSpec
+        
+        reg_funcs = self._schema.get('registered_functions', {})
+        reconstructed = []
+        skipped = []
+        
+        for name, spec_dict in reg_funcs.items():
+            func_type = spec_dict.get('type')
+            
+            if func_type == 'evaluator':
+                # Evaluators must be re-registered manually
+                skipped.append(f"{name} (evaluator — re-register manually)")
+                continue
+            
+            # Polynomial reconstruction
+            coeff_subframe = spec_dict.get('coefficients_subframe')
+            coeff_select = spec_dict.get('coeff_select')
+            
+            if not coeff_subframe or not coeff_select:
+                skipped.append(f"{name} (missing coefficients_subframe or coeff_select)")
+                continue
+            
+            # Check if subframe is registered
+            try:
+                sf = self.get_subframe(coeff_subframe)
+                if sf is None:
+                    skipped.append(f"{name} (subframe '{coeff_subframe}' not registered)")
+                    continue
+            except (KeyError, AttributeError):
+                skipped.append(f"{name} (subframe '{coeff_subframe}' not found)")
+                continue
+            
+            # Reconstruct PolynomialSpec from schema
+            try:
+                poly_spec = PolynomialSpec.from_schema(spec_dict)
+                self.register_polynomial_from_subframe(
+                    name, poly_spec, coeff_subframe, coeff_select, overwrite=True
+                )
+                reconstructed.append(name)
+            except Exception as e:
+                skipped.append(f"{name} (reconstruction failed: {e})")
+        
+        if reconstructed:
+            print(f"[apply_schema] Reconstructed {len(reconstructed)} polynomial functions: {reconstructed}")
+        if skipped:
+            print(f"[apply_schema] Skipped {len(skipped)} functions: {skipped}")
 
     @classmethod
     def from_schema(cls, schema):

UTILS/dfextensions/AliasDataFrame/tests/test_polynomial_persistence.py

@@ -0,0 +1,181 @@
+"""
+Tests for Phase 13.9.Fix1: Polynomial function persistence
+
+Registered polynomial functions must survive schema export/import cycle.
+After loading, polynomial aliases should be functional without manual
+re-registration.
+"""
+
+import pytest
+import numpy as np
+import pandas as pd
+import json
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from AliasDataFrame import AliasDataFrame
+from PolynomialSpec import PolynomialSpec
+
+
+@pytest.fixture
+def adf_with_polynomial():
+    """ADF with registered polynomial from subframe."""
+    df_main = pd.DataFrame({
+        'group': np.array([0, 0, 1, 1, 0, 1]),
+        'x': np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]),
+        'y': np.array([0.5, 1.5, 2.5, 3.5, 4.5, 5.5]),
+    })
+    # Coefficients: group 0 → [1.0, 0.5, 0.2, 0.05], group 1 → [2.0, -0.3, 0.1, -0.02]
+    # Terms: x^0*y^0, x^1*y^0, x^0*y^1, x^1*y^1
+    df_coeffs = pd.DataFrame({
+        'group': [0, 1],
+        'c_x0_y0': [1.0, 2.0],
+        'c_x1_y0': [0.5, -0.3],
+        'c_x0_y1': [0.2, 0.1],
+        'c_x1_y1': [0.05, -0.02],
+    })
+
+    adf = AliasDataFrame(df_main)
+    adf.register_subframe('Coeffs', AliasDataFrame(df_coeffs), index_columns=['group'])
+
+    spec = PolynomialSpec(columns=['x', 'y'], degrees=(1, 1))
+    coeff_cols = ['c_x0_y0', 'c_x1_y0', 'c_x0_y1', 'c_x1_y1']
+    adf.register_polynomial_from_subframe('poly', spec, 'Coeffs', coeff_cols)
+    adf.add_alias('correction', 'poly(x, y)')
+
+    return adf, spec, coeff_cols
+
+
+class TestPolynomialPersistence:
+    """Phase 13.9.Fix1: Polynomial function persistence."""
+
+    def test_schema_contains_registered_functions(self, adf_with_polynomial):
+        """export_schema includes registered_functions."""
+        adf, _, _ = adf_with_polynomial
+        schema = adf.export_schema()
+        assert 'registered_functions' in schema
+        assert 'poly' in schema['registered_functions']
+        assert schema['registered_functions']['poly']['coefficients_subframe'] == 'Coeffs'
+
+    def test_schema_has_polynomial_spec(self, adf_with_polynomial):
+        """Schema stores PolynomialSpec details for reconstruction."""
+        adf, _, coeff_cols = adf_with_polynomial
+        schema = adf.export_schema()
+        poly_schema = schema['registered_functions']['poly']
+        assert poly_schema['coeff_select'] == coeff_cols
+        assert 'columns' in poly_schema or 'dimensions' in poly_schema
+
+    def test_schema_json_serializable(self, adf_with_polynomial):
+        """Schema with registered_functions is JSON serializable."""
+        adf, _, _ = adf_with_polynomial
+        schema = adf.export_schema()
+        json_str = json.dumps(schema)
+        restored = json.loads(json_str)
+        assert 'registered_functions' in restored
+
+    def test_save_load_schema_roundtrip(self, adf_with_polynomial, tmp_path):
+        """Schema saves and loads with registered_functions intact."""
+        adf, _, _ = adf_with_polynomial
+        schema_path = str(tmp_path / 'schema.json')
+        adf.save_schema(schema_path)
+
+        loaded_schema = AliasDataFrame.load_schema(schema_path)
+        assert 'registered_functions' in loaded_schema
+        assert 'poly' in loaded_schema['registered_functions']
+
+    def test_reconstruct_polynomial_from_schema(self, adf_with_polynomial):
+        """apply_schema reconstructs polynomial functions."""
+        adf, spec, coeff_cols = adf_with_polynomial
+
+        # Get reference values
+        adf.materialize_alias('correction')
+        reference = adf.df['correction'].values.copy()
+
+        # Export schema
+        schema = adf.export_schema()
+
+        # Create new ADF with same data + subframe
+        df_main = adf.df[['group', 'x', 'y']].copy()
+        sf = adf.get_subframe('Coeffs')
+        adf2 = AliasDataFrame(df_main)
+        adf2.register_subframe('Coeffs', AliasDataFrame(sf.df.copy()), index_columns=['group'])
+
+        # Apply schema — should reconstruct polynomial
+        adf2.apply_schema(schema)
+
+        # Alias should work now
+        adf2.materialize_alias('correction')
+        np.testing.assert_allclose(adf2.df['correction'].values, reference, atol=1e-10)
+
+    def test_reconstruct_skips_evaluator(self, adf_with_polynomial):
+        """Evaluator functions are skipped during reconstruction (by design)."""
+        adf, _, _ = adf_with_polynomial
+
+        # Add a fake evaluator entry to schema
+        adf._schema['registered_functions']['my_eval'] = {
+            'type': 'evaluator',
+            'coord_columns': ['x'],
+            'predictor_columns': None,
+        }
+
+        schema = adf.export_schema()
+
+        # Create new ADF
+        df_main = adf.df[['group', 'x', 'y']].copy()
+        sf = adf.get_subframe('Coeffs')
+        adf2 = AliasDataFrame(df_main)
+        adf2.register_subframe('Coeffs', AliasDataFrame(sf.df.copy()), index_columns=['group'])
+        adf2.apply_schema(schema)
+
+        # Polynomial should be reconstructed, evaluator should not
+        assert 'poly' in adf2._registered_functions
+        assert 'my_eval' not in adf2._registered_functions
+
+    def test_reconstruct_missing_subframe_skips(self):
+        """Reconstruction skips if subframe not registered."""
+        df = pd.DataFrame({'x': [1.0, 2.0], 'y': [0.5, 1.5]})
+        adf = AliasDataFrame(df)
+
+        schema = {
+            'registered_functions': {
+                'poly': {
+                    'columns': ['x', 'y'],
+                    'degrees': [1, 1],
+                    'coefficients_subframe': 'MissingSF',
+                    'coeff_select': ['c0', 'c1', 'c2', 'c3'],
+                }
+            }
+        }
+
+        # Should not raise — just skip with message
+        adf.apply_schema(schema)
+        assert 'poly' not in getattr(adf, '_registered_functions', {})
+
+    @pytest.mark.invariance
+    def test_invariance_before_after_schema_roundtrip(self, adf_with_polynomial, tmp_path):
+        """Invariance: polynomial values identical before and after schema roundtrip."""
+        adf, _, _ = adf_with_polynomial
+
+        # Before
+        adf.materialize_alias('correction')
+        before = adf.df['correction'].values.copy()
+
+        # Save schema
+        schema_path = str(tmp_path / 'schema.json')
+        adf.save_schema(schema_path)
+
+        # Reconstruct
+        df_main = adf.df[['group', 'x', 'y']].copy()
+        sf = adf.get_subframe('Coeffs')
+        adf2 = AliasDataFrame(df_main)
+        adf2.register_subframe('Coeffs', AliasDataFrame(sf.df.copy()), index_columns=['group'])
+        loaded = AliasDataFrame.load_schema(schema_path)
+        adf2.apply_schema(loaded)
+
+        # After
+        adf2.materialize_alias('correction')
+        after = adf2.df['correction'].values.copy()
+
+        np.testing.assert_allclose(before, after, atol=1e-10,
+                                    err_msg="Polynomial values differ after schema roundtrip")