fix: removed convenience functions for testing

Author: Ren-creater

evaluation_function/correction/README.md

@@ -2,11 +2,17 @@
 
 Compares student FSAs against expected FSAs, leveraging the validation module for detailed feedback.
 
-## Architecture
+## Exports
 
-The correction module is a wrapper around the validation module. All detailed "why" feedback comes from `are_isomorphic()` in `validation.py`.
+```python
+from evaluation_function.correction import (
+    analyze_fsa_correction,  # Main pipeline
+    check_minimality,        # Check if FSA is minimal
+    CorrectionResult,        # Result model
+)
+```
 
-## Pipeline (4 Steps)
+## Pipeline
 
 ```
 ┌─────────────────────────────────────────────────────────────────┐
@@ -23,46 +29,42 @@ The correction module is a wrapper around the validation module. All detailed "w
 │  └── get_structured_info_of_fsa() → StructuralInfo              │
 ├─────────────────────────────────────────────────────────────────┤
 │  Step 4: Language Equivalence                                    │
-│  └── fsas_accept_same_language()                                │
-│      └── are_isomorphic() provides detailed feedback:            │
-│          • State acceptance errors with ElementHighlight         │
-│          • Transition errors with ElementHighlight               │
-│          • Alphabet mismatches                                   │
-│          • State count differences                               │
+│  └── fsas_accept_same_language() → are_isomorphic()             │
+│      Provides detailed feedback with ElementHighlight            │
 ├─────────────────────────────────────────────────────────────────┤
 │  OUTPUT: CorrectionResult                                        │
 │  ├── is_equivalent: bool                                         │
 │  ├── is_isomorphic: bool                                         │
 │  ├── is_minimal: Optional[bool]                                  │
 │  ├── validation_errors: List[ValidationError]                   │
-│  ├── equivalence_errors: List[ValidationError] (from isomorphism)│
+│  ├── equivalence_errors: List[ValidationError]                  │
 │  └── structural_info: StructuralInfo                            │
+│                                                                  │
+│  Methods:                                                        │
+│  ├── .model_dump() → dict                                       │
+│  ├── .to_fsa_feedback() → FSAFeedback                           │
+│  └── .get_language_comparison() → LanguageComparison            │
 └─────────────────────────────────────────────────────────────────┘
 ```
 
 ## Usage
 
 ```python
-from evaluation_function.correction import analyze_fsa_correction, get_fsa_feedback
+from evaluation_function.correction import analyze_fsa_correction, check_minimality
 
-# Full analysis
+# Compare two FSAs
 result = analyze_fsa_correction(student_fsa, expected_fsa, check_minimality=True)
-print(result.is_equivalent)
-print(result.equivalence_errors)  # Detailed errors from are_isomorphic()
+
+# Check result
+result.is_equivalent      # bool
+result.equivalence_errors # List[ValidationError] with ElementHighlight
 
 # For UI
-feedback = get_fsa_feedback(student_fsa, expected_fsa)
-print(feedback.summary)
-print(feedback.errors)  # List[ValidationError] with ElementHighlight
-```
+result.to_fsa_feedback()  # FSAFeedback schema
 
-## Functions
+# As dict
+result.model_dump()       # dict
 
-| Function | Returns | Description |
-|----------|---------|-------------|
-| `analyze_fsa_correction` | `CorrectionResult` | Full comparison pipeline |
-| `get_fsa_feedback` | `FSAFeedback` | Structured feedback for UI |
-| `get_correction_feedback` | `dict` | Same as above, as dict |
-| `check_fsa_properties` | `dict` | Properties of single FSA |
-| `check_minimality` | `bool` | Is FSA minimal? |
-| `quick_equivalence_check` | `tuple` | Fast equivalence check |
+# Check minimality only
+check_minimality(fsa)     # bool
+```

evaluation_function/correction/__init__.py

@@ -1,45 +1,21 @@
-"""
-FSA Correction Module
-
-Compares student FSAs against expected FSAs using the validation module.
-
-Pipeline (4 Steps):
-1. Structural Validation - is_valid_fsa
-2. Minimality Check - check_minimality (if required)
-3. Structural Analysis - get_structured_info_of_fsa
-4. Language Equivalence - fsas_accept_same_language (-> are_isomorphic)
+"""FSA Correction Module
 
-The validation module's are_isomorphic() provides all "why" feedback:
-- State acceptance errors with ElementHighlight
-- Transition errors (missing/extra/wrong) with ElementHighlight
-- Alphabet and state count mismatches
+Compares student FSAs against expected FSAs.
 
-Main Functions:
-- analyze_fsa_correction: Full pipeline (FSA vs FSA -> CorrectionResult)
-- get_fsa_feedback: Returns FSAFeedback schema (for UI)
-- check_fsa_properties: Structural properties of single FSA
-- check_minimality: Verify FSA is minimal
+Exports:
+- analyze_fsa_correction: Main pipeline (FSA vs FSA -> CorrectionResult)
+- check_minimality: Check if FSA is minimal
+- CorrectionResult: Result model with .to_fsa_feedback(), .model_dump()
 """
 
 from .correction import (
-    # Main pipeline
     analyze_fsa_correction,
-    get_correction_feedback,
-    get_fsa_feedback,
-    check_fsa_properties,
     check_minimality,
-    quick_equivalence_check,
-    
-    # Result class
     CorrectionResult,
 )
 
 __all__ = [
     "analyze_fsa_correction",
-    "get_correction_feedback",
-    "get_fsa_feedback",
-    "check_fsa_properties",
     "check_minimality",
-    "quick_equivalence_check",
     "CorrectionResult",
 ]

evaluation_function/correction/correction.py

@@ -24,13 +24,9 @@
 from ..schemas import FSA, ValidationError, ErrorCode
 from ..schemas.result import LanguageComparison, StructuralInfo, FSAFeedback
 
-# Validation imports - these provide all the functionality we need
+# Validation imports
 from ..validation.validation import (
     is_valid_fsa,
-    is_deterministic,
-    is_complete,
-    find_unreachable_states,
-    find_dead_states,
     fsas_accept_same_language,
     get_structured_info_of_fsa,
 )
@@ -221,104 +217,3 @@ def analyze_fsa_correction(
 
     result.summary = f"Languages differ: {', '.join(error_types) if error_types else f'{len(equiv_errors)} issue(s)'}"
     return result
-
-
-# =============================================================================
-# Convenience Functions
-# =============================================================================
-
-def get_correction_feedback(
-    student_fsa: FSA,
-    expected_fsa: FSA,
-    check_minimality: bool = False
-) -> dict:
-    """Returns correction analysis as dict."""
-    result = analyze_fsa_correction(student_fsa, expected_fsa, check_minimality)
-    return result.model_dump()
-
-
-def get_fsa_feedback(
-    student_fsa: FSA,
-    expected_fsa: FSA,
-    check_minimality: bool = False
-) -> FSAFeedback:
-    """Returns structured FSAFeedback schema (recommended for UI)."""
-    result = analyze_fsa_correction(student_fsa, expected_fsa, check_minimality)
-    return result.to_fsa_feedback()
-
-
-def check_fsa_properties(fsa: FSA) -> dict:
-    """Get FSA properties using validation functions."""
-    result = {
-        "is_valid": True,
-        "is_deterministic": True,
-        "is_complete": True,
-        "is_minimal": True,
-        "validation_errors": [],
-        "determinism_errors": [],
-        "completeness_errors": [],
-        "unreachable_states": [],
-        "dead_states": [],
-        "structural_info": None
-    }
-    
-    validation_errors = is_valid_fsa(fsa)
-    if validation_errors:
-        result["is_valid"] = False
-        result["validation_errors"] = [e.model_dump() for e in validation_errors]
-        return result
-    
-    det_errors = is_deterministic(fsa)
-    result["is_deterministic"] = len(det_errors) == 0
-    result["determinism_errors"] = [e.model_dump() for e in det_errors]
-    
-    if result["is_deterministic"]:
-        comp_errors = is_complete(fsa)
-        result["is_complete"] = len(comp_errors) == 0
-        result["completeness_errors"] = [e.model_dump() for e in comp_errors]
-        result["is_minimal"] = check_minimality(fsa)
-    else:
-        result["is_complete"] = False
-        result["is_minimal"] = False
-    
-    result["unreachable_states"] = [
-        e.highlight.state_id for e in find_unreachable_states(fsa)
-        if e.highlight and e.highlight.state_id
-    ]
-    result["dead_states"] = [
-        e.highlight.state_id for e in find_dead_states(fsa)
-        if e.highlight and e.highlight.state_id
-    ]
-    result["structural_info"] = get_structured_info_of_fsa(fsa).model_dump()
-    
-    return result
-
-
-def quick_equivalence_check(
-    student_fsa: FSA,
-    expected_fsa: FSA
-) -> Tuple[bool, Optional[str], Optional[str]]:
-    """
-    Quick equivalence check.
-    
-    Returns:
-        (are_equivalent, counterexample_hint, hint_type)
-    """
-    if is_valid_fsa(student_fsa) or is_valid_fsa(expected_fsa):
-        return False, None, None
-    
-    equiv_errors = fsas_accept_same_language(student_fsa, expected_fsa)
-    if not equiv_errors:
-        return True, None, None
-    
-    # Extract hint from first error
-    first_error = equiv_errors[0]
-    hint = first_error.message
-    hint_type = None
-    
-    if "accepting" in hint.lower():
-        hint_type = "acceptance_error"
-    elif "transition" in hint.lower():
-        hint_type = "transition_error"
-    
-    return False, hint, hint_type

evaluation_function/test/test_correction.py

@@ -12,11 +12,7 @@
 from evaluation_function.correction import (
     CorrectionResult,
     analyze_fsa_correction,
-    get_correction_feedback,
-    get_fsa_feedback,
-    check_fsa_properties,
     check_minimality,
-    quick_equivalence_check,
 )
 
 
@@ -164,42 +160,6 @@ def test_get_language_comparison(self, dfa_accepts_a, equivalent_dfa):
         assert comparison.are_equivalent is True
 
 
-# =============================================================================
-# Test Convenience Functions
-# =============================================================================
-
-class TestConvenienceFunctions:
-    """Test convenience functions."""
-
-    def test_get_correction_feedback(self, dfa_accepts_a, equivalent_dfa):
-        feedback = get_correction_feedback(dfa_accepts_a, equivalent_dfa)
-        assert isinstance(feedback, dict)
-        assert feedback["is_equivalent"] is True
-
-    def test_get_fsa_feedback(self, dfa_accepts_a, equivalent_dfa):
-        feedback = get_fsa_feedback(dfa_accepts_a, equivalent_dfa)
-        assert isinstance(feedback, FSAFeedback)
-
-    def test_check_fsa_properties(self, dfa_accepts_a):
-        props = check_fsa_properties(dfa_accepts_a)
-        assert props["is_valid"] is True
-        assert props["is_deterministic"] is True
-        assert props["is_complete"] is True
-
-    def test_check_fsa_properties_unreachable(self, dfa_with_unreachable):
-        props = check_fsa_properties(dfa_with_unreachable)
-        assert "unreachable" in props["unreachable_states"]
-
-    def test_quick_equivalence_check_equal(self, dfa_accepts_a, equivalent_dfa):
-        is_equiv, hint, hint_type = quick_equivalence_check(dfa_accepts_a, equivalent_dfa)
-        assert is_equiv is True
-
-    def test_quick_equivalence_check_different(self, dfa_accepts_a, dfa_accepts_a_or_b):
-        is_equiv, hint, hint_type = quick_equivalence_check(dfa_accepts_a, dfa_accepts_a_or_b)
-        assert is_equiv is False
-        assert hint is not None
-
-
 # =============================================================================
 # Test Invalid FSAs
 # =============================================================================