Update quant_solver.py

quant_solver.py

@@ -7,6 +7,7 @@ from statistics import mean, median
 from typing import Dict, List, Optional
 
 from models import SolverResult
+from solver_router import route_solver
 from utils import clean_math_text, normalize_spaces
 
 try:
@@ -58,12 +59,43 @@ def extract_numbers(text: str) -> List[float]:
 def is_quant_question(text: str) -> bool:
     lower = text.lower()
     quant_keywords = [
-        "solve", "equation", "integer", "percent", "percentage", "ratio", "probability",
-        "mean", "median", "average", "sum", "difference", "product", "quotient",
-        "triangle", "circle", "rectangle", "perimeter", "area", "volume",
-        "number line", "positive", "negative", "multiple", "factor", "prime",
-        "distance", "speed", "work", "mixture", "consecutive", "algebra",
-        "value of x", "value of y", "what is x", "what is y", "divisible"
+        "solve",
+        "equation",
+        "integer",
+        "percent",
+        "percentage",
+        "ratio",
+        "probability",
+        "mean",
+        "median",
+        "average",
+        "sum",
+        "difference",
+        "product",
+        "quotient",
+        "triangle",
+        "circle",
+        "rectangle",
+        "perimeter",
+        "area",
+        "volume",
+        "number line",
+        "positive",
+        "negative",
+        "multiple",
+        "factor",
+        "prime",
+        "distance",
+        "speed",
+        "work",
+        "mixture",
+        "consecutive",
+        "algebra",
+        "value of x",
+        "value of y",
+        "what is x",
+        "what is y",
+        "divisible",
     ]
     if any(k in lower for k in quant_keywords):
         return True
@@ -101,7 +133,11 @@ def parse_direct_expression_question(text: str) -> Optional[str]:
     return expr
 
 
-def compare_to_choices_numeric(answer_value: float, choices: Dict[str, str], tolerance: float = 1e-9) -> Optional[str]:
+def compare_to_choices_numeric(
+    answer_value: float,
+    choices: Dict[str, str],
+    tolerance: float = 1e-9,
+) -> Optional[str]:
     best_letter = None
     best_diff = float("inf")
 
@@ -127,7 +163,10 @@ def compare_to_choices_numeric(answer_value: float, choices: Dict[str, str], tol
     return None
 
 
-def compare_fraction_to_choices(fraction_text: str, choices: Dict[str, str]) -> Optional[str]:
+def compare_fraction_to_choices(
+    fraction_text: str,
+    choices: Dict[str, str],
+) -> Optional[str]:
     target = fraction_text.strip()
 
     for letter, raw in choices.items():
@@ -160,14 +199,19 @@ def solve_basic_expression(text: str, help_mode: str) -> Optional[SolverResult]:
     else:
         reply = f"The value is {value:g}."
 
-    return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{value:g}")
+    return SolverResult(
+        reply=reply,
+        domain="quant",
+        solved=True,
+        help_mode=help_mode,
+        answer_value=f"{value:g}",
+    )
 
 
 def solve_percent_question(text: str, help_mode: str) -> Optional[SolverResult]:
     lower = text.lower()
     choices = extract_choices(text)
 
-    # percent of number
     m = re.search(r"what is\s+(\d+(?:\.\d+)?)\s*%\s+of\s+(\d+(?:\.\d+)?)", lower)
     if m:
         p = float(m.group(1))
@@ -195,7 +239,6 @@ def solve_percent_question(text: str, help_mode: str) -> Optional[SolverResult]:
             answer_value=f"{ans:g}",
         )
 
-    # x is what percent of y
     m = re.search(r"(\d+(?:\.\d+)?)\s+is\s+what percent of\s+(\d+(?:\.\d+)?)", lower)
     if m:
         x = float(m.group(1))
@@ -204,17 +247,28 @@ def solve_percent_question(text: str, help_mode: str) -> Optional[SolverResult]:
             return None
 
         ans = x / y * 100
+        letter = compare_to_choices_numeric(ans, choices) if choices else None
 
         if help_mode == "hint":
             reply = "Use part ÷ whole × 100."
         elif help_mode == "walkthrough":
             reply = f"Percent = ({x} / {y}) × 100 = {ans:g}%."
+            if letter:
+                reply += f"\nThat matches choice {letter}."
         else:
             reply = f"The answer is {ans:g}%."
+            if letter:
+                reply += f" So the correct choice is {letter}."
 
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}%")
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=True,
+            help_mode=help_mode,
+            answer_letter=letter,
+            answer_value=f"{ans:g}%",
+        )
 
-    # convert percent to fraction
     m = re.search(r"(\d+(?:\.\d+)?)\s*%.*?(?:equals|as a fraction|fraction)", lower)
     if not m:
         m = re.search(r"what is\s+(\d+(?:\.\d+)?)\s*%\s+as a fraction", lower)
@@ -246,7 +300,6 @@ def solve_percent_question(text: str, help_mode: str) -> Optional[SolverResult]:
                 answer_value=fraction_text,
             )
 
-    # increased/decreased by percent
     m = re.search(
         r"(\d+(?:\.\d+)?)\s+(?:is\s+)?(increased|decreased)\s+by\s+(\d+(?:\.\d+)?)\s*%",
         lower,
@@ -256,16 +309,28 @@ def solve_percent_question(text: str, help_mode: str) -> Optional[SolverResult]:
         direction = m.group(2)
         p = float(m.group(3)) / 100
         ans = base * (1 + p) if direction == "increased" else base * (1 - p)
+        letter = compare_to_choices_numeric(ans, choices) if choices else None
 
         if help_mode == "hint":
             reply = "Use multiplier form: increase → 1 + p, decrease → 1 - p."
         elif help_mode == "walkthrough":
             mult = 1 + p if direction == "increased" else 1 - p
             reply = f"Multiplier = {mult:g}, so {base:g} × {mult:g} = {ans:g}."
+            if letter:
+                reply += f"\nThat matches choice {letter}."
         else:
             reply = f"The result is {ans:g}."
+            if letter:
+                reply += f" So the correct choice is {letter}."
 
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=True,
+            help_mode=help_mode,
+            answer_letter=letter,
+            answer_value=f"{ans:g}",
+        )
 
     return None
 
@@ -275,12 +340,12 @@ def solve_ratio_question(text: str, help_mode: str) -> Optional[SolverResult]:
 
     m = re.search(
         r"ratio of .*? is\s+(\d+)\s*:\s*(\d+).*?total (?:is|of)\s+(\d+(?:\.\d+)?)",
-        lower
+        lower,
     )
     if not m:
         m = re.search(
             r"(\d+)\s*:\s*(\d+).*?total (?:is|of)\s+(\d+(?:\.\d+)?)",
-            lower
+            lower,
         )
 
     if m:
@@ -305,48 +370,80 @@ def solve_ratio_question(text: str, help_mode: str) -> Optional[SolverResult]:
         else:
             reply = f"The two quantities are {first:g} and {second:g}."
 
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{first:g}, {second:g}")
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=True,
+            help_mode=help_mode,
+            answer_value=f"{first:g}, {second:g}",
+        )
 
     return None
 
 
 def solve_average_question(text: str, help_mode: str) -> Optional[SolverResult]:
     lower = text.lower()
+    choices = extract_choices(text)
 
     if "mean" in lower or "average" in lower:
         nums = extract_numbers(text)
         if len(nums) >= 2:
             ans = mean(nums)
+            letter = compare_to_choices_numeric(ans, choices) if choices else None
 
             if help_mode == "hint":
                 reply = "Add the numbers, then divide by how many there are."
             elif help_mode == "walkthrough":
                 reply = f"The numbers are {', '.join(f'{x:g}' for x in nums)}.\nTheir average is {ans:g}."
+                if letter:
+                    reply += f"\nThat matches choice {letter}."
             else:
                 reply = f"The average is {ans:g}."
+                if letter:
+                    reply += f" So the correct choice is {letter}."
 
-            return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
+            return SolverResult(
+                reply=reply,
+                domain="quant",
+                solved=True,
+                help_mode=help_mode,
+                answer_letter=letter,
+                answer_value=f"{ans:g}",
+            )
 
     if "median" in lower:
         nums = extract_numbers(text)
         if len(nums) >= 2:
             ans = median(nums)
+            letter = compare_to_choices_numeric(ans, choices) if choices else None
 
             if help_mode == "hint":
                 reply = "Sort the numbers first, then take the middle value."
             elif help_mode == "walkthrough":
                 s = sorted(nums)
                 reply = f"Sorted numbers: {', '.join(f'{x:g}' for x in s)}.\nThe median is {ans:g}."
+                if letter:
+                    reply += f"\nThat matches choice {letter}."
             else:
                 reply = f"The median is {ans:g}."
+                if letter:
+                    reply += f" So the correct choice is {letter}."
 
-            return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
+            return SolverResult(
+                reply=reply,
+                domain="quant",
+                solved=True,
+                help_mode=help_mode,
+                answer_letter=letter,
+                answer_value=f"{ans:g}",
+            )
 
     return None
 
 
 def solve_probability_question(text: str, help_mode: str) -> Optional[SolverResult]:
     lower = text.lower()
+    choices = extract_choices(text)
 
     m = re.search(r"(\d+)\s+red.*?(\d+)\s+blue.*?probability", lower)
     if m:
@@ -357,15 +454,30 @@ def solve_probability_question(text: str, help_mode: str) -> Optional[SolverResu
             return None
 
         ans = r / total
+        letter = compare_to_choices_numeric(ans, choices) if choices else None
 
         if help_mode == "hint":
             reply = "Probability = favorable outcomes ÷ total outcomes."
         elif help_mode == "walkthrough":
-            reply = f"Favorable outcomes = {r:g}, total outcomes = {total:g}, so probability = {r:g}/{total:g} = {ans:g}."
+            reply = (
+                f"Favorable outcomes = {r:g}, total outcomes = {total:g}, "
+                f"so probability = {r:g}/{total:g} = {ans:g}."
+            )
+            if letter:
+                reply += f"\nThat matches choice {letter}."
         else:
             reply = f"The probability is {ans:g}."
+            if letter:
+                reply += f" So the correct choice is {letter}."
 
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=True,
+            help_mode=help_mode,
+            answer_letter=letter,
+            answer_value=f"{ans:g}",
+        )
 
     return None
 
@@ -374,7 +486,6 @@ def solve_geometry_question(text: str, help_mode: str) -> Optional[SolverResult]
     lower = text.lower()
     choices = extract_choices(text)
 
-    # rectangle perimeter with one side known -> find other side
     m = re.search(
         r"rectangle.*?perimeter\s*(?:is|=)?\s*(\d+(?:\.\d+)?).*?length\s*(?:is|=)?\s*(\d+(?:\.\d+)?)",
         lower,
@@ -389,11 +500,6 @@ def solve_geometry_question(text: str, help_mode: str) -> Optional[SolverResult]
             reply = "Use the perimeter formula for a rectangle: P = 2(L + W)."
         elif help_mode == "walkthrough":
             reply = (
-                f"For a rectangle, P = 2(L + W).\n"
-                f"So 30 = 2(9 + W).\n"
-                f"Divide by 2: 15 = 9 + W.\n"
-                f"So W = {ans:g}."
-            ) if p == 30 and l == 9 else (
                 f"For a rectangle, P = 2(L + W).\n"
                 f"So {p:g} = 2({l:g} + W).\n"
                 f"Divide by 2: {p/2:g} = {l:g} + W.\n"
@@ -415,49 +521,91 @@ def solve_geometry_question(text: str, help_mode: str) -> Optional[SolverResult]
             answer_value=f"{ans:g}",
         )
 
-    m = re.search(r"rectangle.*?length\s*(?:is|=)?\s*(\d+(?:\.\d+)?)\D+width\s*(?:is|=)?\s*(\d+(?:\.\d+)?)", lower)
+    m = re.search(
+        r"rectangle.*?length\s*(?:is|=)?\s*(\d+(?:\.\d+)?)\D+width\s*(?:is|=)?\s*(\d+(?:\.\d+)?)",
+        lower,
+    )
     if m and "area" in lower:
         l = float(m.group(1))
         w = float(m.group(2))
         ans = l * w
+        letter = compare_to_choices_numeric(ans, choices) if choices else None
 
         if help_mode == "hint":
             reply = "For a rectangle, area = length × width."
         elif help_mode == "walkthrough":
             reply = f"Area = {l:g} × {w:g} = {ans:g}."
+            if letter:
+                reply += f"\nThat matches choice {letter}."
         else:
             reply = f"The area is {ans:g}."
+            if letter:
+                reply += f" So the correct choice is {letter}."
 
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=True,
+            help_mode=help_mode,
+            answer_letter=letter,
+            answer_value=f"{ans:g}",
+        )
 
     m = re.search(r"circle.*?radius\s*(?:is|=)?\s*(\d+(?:\.\d+)?)", lower)
     if m and "area" in lower:
         r = float(m.group(1))
         ans = math.pi * r * r
+        letter = compare_to_choices_numeric(ans, choices) if choices else None
 
         if help_mode == "hint":
             reply = "For a circle, area = πr²."
         elif help_mode == "walkthrough":
             reply = f"Area = π({r:g})² = {ans:.4f}."
+            if letter:
+                reply += f"\nThat matches choice {letter}."
         else:
             reply = f"The area is {ans:.4f}."
+            if letter:
+                reply += f" So the correct choice is {letter}."
 
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:.4f}")
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=True,
+            help_mode=help_mode,
+            answer_letter=letter,
+            answer_value=f"{ans:.4f}",
+        )
 
-    m = re.search(r"triangle.*?base\s*(?:is|=)?\s*(\d+(?:\.\d+)?)\D+height\s*(?:is|=)?\s*(\d+(?:\.\d+)?)", lower)
+    m = re.search(
+        r"triangle.*?base\s*(?:is|=)?\s*(\d+(?:\.\d+)?)\D+height\s*(?:is|=)?\s*(\d+(?:\.\d+)?)",
+        lower,
+    )
     if m and "area" in lower:
         b = float(m.group(1))
         h = float(m.group(2))
         ans = 0.5 * b * h
+        letter = compare_to_choices_numeric(ans, choices) if choices else None
 
         if help_mode == "hint":
             reply = "Triangle area = 1/2 × base × height."
         elif help_mode == "walkthrough":
             reply = f"Area = 1/2 × {b:g} × {h:g} = {ans:g}."
+            if letter:
+                reply += f"\nThat matches choice {letter}."
         else:
             reply = f"The area is {ans:g}."
+            if letter:
+                reply += f" So the correct choice is {letter}."
 
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=True,
+            help_mode=help_mode,
+            answer_letter=letter,
+            answer_value=f"{ans:g}",
+        )
 
     return None
 
@@ -488,7 +636,7 @@ def solve_divisibility_question(text: str, help_mode: str) -> Optional[SolverRes
         elif help_mode == "walkthrough":
             reply = (
                 f"Substitute the choices into 3x + 2.\n"
-                f"When x = {valid_x}, 3({valid_x}) + 2 = {3*valid_x+2}, which is divisible by 5.\n"
+                f"When x = {valid_x}, 3({valid_x}) + 2 = {3 * valid_x + 2}, which is divisible by 5.\n"
                 f"So the correct choice is {valid_letter}."
             )
         else:
@@ -511,8 +659,12 @@ def solve_linear_equation(text: str, help_mode: str) -> Optional[SolverResult]:
         return None
 
     lower = text.lower().replace("^", "**")
+    choices = extract_choices(text)
 
-    m = re.search(r"(?:solve for x|find x|value of x).*?([\-0-9a-z\+\*/\s\(\)]+=[\-0-9a-z\+\*/\s\(\)]+)", lower)
+    m = re.search(
+        r"(?:solve for x|find x|value of x).*?([\-0-9a-z\+\*/\s\(\)]+=[\-0-9a-z\+\*/\s\(\)]+)",
+        lower,
+    )
     if not m:
         m = re.search(r"([\-0-9a-z\+\*/\s\(\)]+=[\-0-9a-z\+\*/\s\(\)]+)", lower)
         if not m:
@@ -534,16 +686,37 @@ def solve_linear_equation(text: str, help_mode: str) -> Optional[SolverResult]:
         if not sols:
             return None
 
-        sol = sols[0]
+        sol = sp.simplify(sols[0])
+
+        sol_float = None
+        try:
+            sol_float = float(sol)
+        except Exception:
+            pass
+
+        letter = None
+        if choices and sol_float is not None:
+            letter = compare_to_choices_numeric(sol_float, choices)
 
         if help_mode == "hint":
             reply = "Collect the x-terms on one side and constants on the other."
         elif help_mode == "walkthrough":
-            reply = f"Solve {eq_text} for x.\nThis gives x = {sp.simplify(sol)}."
+            reply = f"Solve {eq_text} for x.\nThis gives x = {sol}."
+            if letter:
+                reply += f"\nThat matches choice {letter}."
         else:
-            reply = f"x = {sp.simplify(sol)}."
+            reply = f"x = {sol}."
+            if letter:
+                reply += f" So the correct choice is {letter}."
 
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=str(sp.simplify(sol)))
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=True,
+            help_mode=help_mode,
+            answer_letter=letter,
+            answer_value=str(sol),
+        )
     except Exception:
         return None
 
@@ -566,7 +739,14 @@ def solve_by_option_checking(text: str, help_mode: str) -> Optional[SolverResult
                 else:
                     reply = f"The correct choice is {letter}."
 
-                return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_letter=letter, answer_value=f"{val:g}")
+                return SolverResult(
+                    reply=reply,
+                    domain="quant",
+                    solved=True,
+                    help_mode=help_mode,
+                    answer_letter=letter,
+                    answer_value=f"{val:g}",
+                )
 
     lower = text.lower()
     m = re.search(r"what is\s+(\d+(?:\.\d+)?)\s*%\s+of\s+(\d+(?:\.\d+)?)", lower)
@@ -581,23 +761,67 @@ def solve_by_option_checking(text: str, help_mode: str) -> Optional[SolverResult
             else:
                 reply = f"The correct choice is {letter}."
 
-            return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_letter=letter, answer_value=f"{val:g}")
+            return SolverResult(
+                reply=reply,
+                domain="quant",
+                solved=True,
+                help_mode=help_mode,
+                answer_letter=letter,
+                answer_value=f"{val:g}",
+            )
 
     return None
 
 
 def solve_quant(text: str, help_mode: str) -> SolverResult:
-    solvers = [
-        solve_by_option_checking,
-        solve_percent_question,
-        solve_ratio_question,
-        solve_average_question,
-        solve_probability_question,
-        solve_geometry_question,
-        solve_divisibility_question,
-        solve_linear_equation,
-        solve_basic_expression,
-    ]
+    solver_type = route_solver(text)
+
+    routed_solvers = {
+        "percent_solver": [
+            solve_by_option_checking,
+            solve_percent_question,
+            solve_basic_expression,
+        ],
+        "ratio_solver": [
+            solve_by_option_checking,
+            solve_ratio_question,
+            solve_basic_expression,
+        ],
+        "algebra_solver": [
+            solve_by_option_checking,
+            solve_linear_equation,
+            solve_divisibility_question,
+            solve_basic_expression,
+        ],
+        "statistics_solver": [
+            solve_by_option_checking,
+            solve_average_question,
+            solve_basic_expression,
+        ],
+        "probability_solver": [
+            solve_by_option_checking,
+            solve_probability_question,
+            solve_basic_expression,
+        ],
+        "geometry_solver": [
+            solve_by_option_checking,
+            solve_geometry_question,
+            solve_basic_expression,
+        ],
+        "basic_solver": [
+            solve_by_option_checking,
+            solve_percent_question,
+            solve_ratio_question,
+            solve_average_question,
+            solve_probability_question,
+            solve_geometry_question,
+            solve_divisibility_question,
+            solve_linear_equation,
+            solve_basic_expression,
+        ],
+    }
+
+    solvers = routed_solvers.get(solver_type, routed_solvers["basic_solver"])
 
     for solver in solvers:
         try:
@@ -607,6 +831,15 @@ def solve_quant(text: str, help_mode: str) -> SolverResult:
         except Exception:
             pass
 
+    if solver_type != "basic_solver":
+        for solver in routed_solvers["basic_solver"]:
+            try:
+                out = solver(text, help_mode)
+                if out:
+                    return out
+            except Exception:
+                pass
+
     if help_mode == "hint":
         reply = (
             "Identify the question type first, then use the key relationship or formula. "
@@ -618,8 +851,11 @@ def solve_quant(text: str, help_mode: str) -> SolverResult:
             "I can still talk through the first step or eliminate options if needed."
         )
     else:
-        reply = (
-            "I can help with this, but I can’t confidently solve it from the current parse alone yet."
-        )
-
-    return SolverResult(reply=reply, domain="quant", solved=False, help_mode=help_mode)
+        reply = "I can help with this, but I can’t confidently solve it from the current parse alone yet."
+
+    return SolverResult(
+        reply=reply,
+        domain="quant",
+        solved=False,
+        help_mode=help_mode,
+    )