feat(v2.0): Phase C — verification_method on all 6 domains, chord fallback=partial [22/22 tests pass]

backend/tests/test_pipeline.py

@@ -61,12 +61,14 @@ class TestVerifierRobustness(unittest.TestCase):
             constraints=["AD is a diameter"],
         )
         result = verifier.verify(schema)
-        self.assertEqual(result.verification_status, "verified")
+        # Chord midpoint fallback is always partial — center is unconfirmed without line eqs
+        self.assertEqual(result.verification_status, "partial")
         center = result.verified.get("center")
         self.assertIsNotNone(center, "Center must be in verified")
         self.assertAlmostEqual(center[0], 0.0, places=4)
         self.assertAlmostEqual(center[1], 5.0, places=4)
         self.assertAlmostEqual(result.verified.get("radius"), 4.0, places=4)
+        self.assertEqual(result.verified.get("verification_method"), "chord_midpoint_fallback")
 
     def test_algebra_insufficient_data(self):
         schema = MathProblemSchema(
@@ -278,3 +280,118 @@ class TestVariablePinner(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)
+
+
+# ============================================================
+# Phase C — 5-Domain Acceptance Suite
+# Each test verifies: (1) correct result, (2) verification_method field
+# ============================================================
+class TestPhaseCDomainCoverage(unittest.TestCase):
+    """
+    Phase C acceptance criterion:
+    Each domain must report WHAT was verified AND HOW (verification_method).
+    5 exam-style exercises, one per remaining domain.
+    """
+
+    # 🔴 ALGEBRA: substitution into original equation
+    def test_algebra_cubic_roots_and_method(self):
+        """x^3 - 6x^2 + 11x - 6 = 0 → roots [1, 2, 3]"""
+        schema = MathProblemSchema(
+            problem_type="algebra",
+            sub_type="cubic",
+            given={"equation": "x**3 - 6*x**2 + 11*x - 6"},
+            find=["roots"],
+            constraints=[],
+        )
+        result = verifier.verify(schema)
+        self.assertEqual(result.verification_status, "verified")
+        solutions = result.verified.get("solutions", [])
+        self.assertIn("1", solutions)
+        self.assertIn("2", solutions)
+        self.assertIn("3", solutions)
+        self.assertEqual(result.verified.get("verification_method"), "sympy_solve_substitution")
+        print(f"  [algebra] method={result.verified.get('verification_method')}")
+
+    # 🔴 GEOMETRY: diameter line intersection (already covered, here as Phase C entry)
+    def test_geometry_circle_diameter_intersection_and_method(self):
+        """y=2x+1 ∩ y=-2x+9 → center (2, 5)"""
+        schema = MathProblemSchema(
+            problem_type="geometry",
+            sub_type="circle",
+            given={"diameter_lines": ["y=2*x+1", "y=-2*x+9"]},
+            find=["center"],
+            constraints=["given lines are diameters"],
+        )
+        result = verifier.verify(schema)
+        self.assertIn(result.verification_status, ["verified", "partial"])
+        M = result.verified.get("M")
+        self.assertIsNotNone(M)
+        self.assertAlmostEqual(M[0], 2.0, places=3)
+        self.assertAlmostEqual(M[1], 5.0, places=3)
+        self.assertEqual(result.verified.get("verification_method"), "diameter_line_intersection")
+        print(f"  [geometry] M={M} method={result.verified.get('verification_method')}")
+
+    # 🟡 PROBABILITY: sum-to-1 check
+    def test_probability_three_event_distribution_and_method(self):
+        """P(A)=1/3, P(B)=1/2, P(C)=1/6 → sum=1"""
+        schema = MathProblemSchema(
+            problem_type="probability",
+            sub_type="discrete_distribution",
+            given={"probabilities": ["1/3", "1/2", "1/6"]},
+            find=["verify distribution is valid"],
+            constraints=["A, B, C are mutually exclusive and exhaustive"],
+        )
+        result = verifier.verify(schema)
+        self.assertEqual(result.verification_status, "verified")
+        self.assertAlmostEqual(result.verified.get("sum"), 1.0, places=9)
+        self.assertEqual(result.verified.get("verification_method"), "sympy_rational_sum")
+        print(f"  [probability] sum={result.verified.get('sum')} method={result.verified.get('verification_method')}")
+
+    # 🟡 STATISTICS: mean and std via NumPy
+    def test_statistics_exam_scores_and_method(self):
+        """Scores [70, 80, 90, 100] → mean=85, std=11.18"""
+        schema = MathProblemSchema(
+            problem_type="statistics",
+            sub_type="descriptive",
+            given={"data": [70, 80, 90, 100]},
+            find=["mean", "standard deviation"],
+            constraints=[],
+        )
+        result = verifier.verify(schema)
+        self.assertEqual(result.verification_status, "verified")
+        self.assertAlmostEqual(result.verified.get("mean"), 85.0, places=4)
+        self.assertAlmostEqual(result.verified.get("std"), 11.1803, places=3)
+        self.assertEqual(result.verified.get("verification_method"), "numpy_population_stats")
+        print(f"  [statistics] mean={result.verified.get('mean')} method={result.verified.get('verification_method')}")
+
+    # 🟢 CALCULUS: derivative at a point
+    def test_calculus_polynomial_derivative_and_method(self):
+        """f(x) = x^3 - 4x → f'(2) = 3*4 - 4 = 8"""
+        schema = MathProblemSchema(
+            problem_type="calculus",
+            sub_type="differentiation",
+            given={"function": "x**3 - 4*x", "point": 2},
+            find=["derivative at x=2"],
+            constraints=[],
+        )
+        result = verifier.verify(schema)
+        self.assertEqual(result.verification_status, "verified")
+        self.assertAlmostEqual(result.verified.get("derivative_at_point"), 8.0, places=4)
+        self.assertEqual(result.verified.get("verification_method"), "sympy_differentiation")
+        print(f"  [calculus] f'(2)={result.verified.get('derivative_at_point')} method={result.verified.get('verification_method')}")
+
+    # 🟢 TRIGONOMETRY: identity verification
+    def test_trigonometry_pythagorean_identity_and_method(self):
+        """sin(x)**2 + cos(x)**2 = 1 → must simplify to 0 symbolically"""
+        schema = MathProblemSchema(
+            problem_type="trigonometry",
+            sub_type="identity",
+            given={"identity": "sin(x)**2 + cos(x)**2 = 1"},
+            find=["verify Pythagorean identity"],
+            constraints=[],
+        )
+        result = verifier.verify(schema)
+        self.assertEqual(result.verification_status, "verified")
+        self.assertTrue(result.verified.get("identity_valid"))
+        self.assertEqual(result.verified.get("verification_method"), "sympy_symbolic_simplification")
+        print(f"  [trig] identity_valid={result.verified.get('identity_valid')} method={result.verified.get('verification_method')}")

backend/universal_verifier.py

@@ -122,8 +122,12 @@ class UniversalVerifier:
                 verified["M"] = (cx, cy)
                 verified["center"] = (cx, cy)
                 verified["center_method"] = "diameter_line_intersection"
+                verified["verification_method"] = "diameter_line_intersection"
                 schema.verified.update(verified)
-                logger.info("✅ [VERIFIER/circle] M = (%s, %s) via %s", cx, cy, method)
+                logger.info(
+                    "✅ [VERIFIER/circle] M = (%s, %s) via %s (method=diameter_line_intersection)",
+                    cx, cy, method,
+                )
 
                 # Verify radius from a known point
                 _compute_radius_from_center(g, center, verified, schema)
@@ -196,11 +200,12 @@ class UniversalVerifier:
             verified["center"] = (float(cx), float(cy))
             verified["M"] = (float(cx), float(cy))
             verified["radius"] = float(computed_radius)
-            verified["center_method"] = "diameter_chord_midpoint"
+            verified["center_method"] = "chord_midpoint_fallback"
+            verified["verification_method"] = "chord_midpoint_fallback"
             schema.verified.update(verified)
 
             logger.info(
-                "📐 [VERIFIER/circle/fallback] midpoint(%s,%s) → center=%s radius=%s",
+                "📐 [VERIFIER/circle/fallback] midpoint(%s,%s) → center=%s radius=%s [FALLBACK — status=partial]",
                 p1_label, p2_label, center, computed_radius,
             )
 
@@ -227,7 +232,11 @@ class UniversalVerifier:
                     )
 
         schema.verified.update(verified)
-        schema.verification_status = "partial" if schema.null_fields() else "verified"
+        # Chord midpoint fallback is always partial — center is unconfirmed without lines
+        if schema.verified.get("center_method") == "chord_midpoint_fallback":
+            schema.verification_status = "partial"
+        else:
+            schema.verification_status = "partial" if schema.null_fields() else "verified"
 
     def _verify_linear(self, schema: MathProblemSchema, g: dict, verified: dict) -> None:
         schema.warnings.append("Linear geometry verifier: basic — extend as needed")
@@ -252,7 +261,8 @@ class UniversalVerifier:
                 expr = sp.sympify(str(equation_str))
             solutions = sp.solve(expr, x)
             verified["solutions"] = [str(s) for s in solutions]
-            logger.info("📐 [VERIFIER/algebra] Solutions: %s", solutions)
+            verified["verification_method"] = "sympy_solve_substitution"
+            logger.info("📐 [VERIFIER/algebra] Solutions: %s (method=sympy_solve_substitution)", solutions)
             given_solution = g.get("solution")
             if given_solution is not None:
                 given_val = sp.Rational(given_solution)
@@ -279,6 +289,8 @@ class UniversalVerifier:
         try:
             total = sum(sp.Rational(str(p)) for p in probs)
             verified["sum"] = float(total)
+            verified["verification_method"] = "sympy_rational_sum"
+            logger.info("📐 [VERIFIER/probability] sum=%s (method=sympy_rational_sum)", float(total))
             if total != 1:
                 schema.warnings.append(
                     f"CONTRADICTION: probabilities sum to {float(total):.4f}, not 1.0"
@@ -304,6 +316,11 @@ class UniversalVerifier:
             arr = np.array([float(x) for x in data])
             verified["mean"] = float(np.mean(arr))
             verified["std"] = float(np.std(arr, ddof=0))
+            verified["verification_method"] = "numpy_population_stats"
+            logger.info(
+                "📐 [VERIFIER/statistics] mean=%.4f std=%.4f (method=numpy_population_stats)",
+                verified["mean"], verified["std"],
+            )
             for key in ("mean", "std"):
                 given_val = g.get(key)
                 if given_val is not None and abs(float(given_val) - verified[key]) > 1e-6:
@@ -335,6 +352,8 @@ class UniversalVerifier:
             diff = sp.simplify(lhs - rhs)
             if diff == 0:
                 verified["identity_valid"] = True
+                verified["verification_method"] = "sympy_symbolic_simplification"
+                logger.info("✅ [VERIFIER/trig] Identity valid (method=sympy_symbolic_simplification)")
                 schema.verification_status = "verified"
             elif angle_deg is not None:
                 angle_rad = sp.Rational(angle_deg) * sp.pi / 180
@@ -363,6 +382,8 @@ class UniversalVerifier:
             f = sp.sympify(str(func_str))
             deriv = sp.diff(f, x)
             verified["derivative"] = str(deriv)
+            verified["verification_method"] = "sympy_differentiation"
+            logger.info("📐 [VERIFIER/calculus] f'(x)=%s (method=sympy_differentiation)", deriv)
             if point_raw is not None:
                 pt = _to_rational(point_raw)
                 val = float(deriv.subs(x, pt))