Update quant_solver.py

quant_solver.py

@@ -50,40 +50,76 @@ def is_quant_question(text: str) -> bool:
 def _prepare_expression(expr: str) -> str:
     expr = clean_math_text(expr).strip()
     expr = expr.replace("^", "**")
+
+    # remove common prompt wrappers
+    expr = re.sub(r"(?i)^\s*(solve|simplify|evaluate|find|what is|compute)\s*:?\s*", "", expr)
+
+    # implicit multiplication
     expr = re.sub(r"(\d)\s*\(", r"\1*(", expr)
     expr = re.sub(r"\)\s*(\d)", r")*\1", expr)
-    expr = re.sub(r"(\d)([a-zA-Z])", r"\1*\2", expr)
+    expr = re.sub(r"(\d)\s*([a-zA-Z])", r"\1*\2", expr)
+    expr = re.sub(r"([a-zA-Z])\s*\(", r"\1*(", expr)
+    expr = re.sub(r"\)\s*([a-zA-Z])", r")*\1", expr)
+    expr = re.sub(r"([a-zA-Z])\s+([a-zA-Z])", r"\1*\2", expr)
+
     return expr
 
 
+def _clean_equation_candidate(text: str) -> str:
+    s = clean_math_text(text).strip()
+
+    # remove leading prompt phrases but keep equation content
+    s = re.sub(r"(?i)^\s*(solve|simplify|evaluate|find)\s*:?\s*", "", s)
+    s = re.sub(r"(?i)^\s*how do i solve\s*:?\s*", "", s)
+    s = re.sub(r"(?i)^\s*what is\s+", "", s)
+    s = normalize_spaces(s)
+    return s
+
+
 def _extract_equation(text: str) -> Optional[str]:
-    cleaned = clean_math_text(text)
+    cleaned = _clean_equation_candidate(text)
     if "=" not in cleaned:
         return None
 
+    # first try: take the full equation-looking span
     patterns = [
-        r"([A-Za-z0-9\.\+\-\*/\^\(\)\s]*[a-zA-Z][A-Za-z0-9\.\+\-\*/\^\(\)\s]*=[A-Za-z0-9\.\+\-\*/\^\(\)\s]+)",
-        r"([0-9A-Za-z\.\+\-\*/\^\(\)\s]+=[0-9A-Za-z\.\+\-\*/\^\(\)\s]+)",
+        r"([A-Za-z0-9\.\+\-\*/\^\(\)\s]+=[A-Za-z0-9\.\+\-\*/\^\(\)\s]+)",
     ]
 
     for pattern in patterns:
         for m in re.finditer(pattern, cleaned):
-            candidate = m.group(1).strip()
-            if re.search(r"[a-z]", candidate.lower()) and not candidate.lower().startswith(
-                ("how do", "can you", "please", "what is", "solve ")
-            ):
+            candidate = normalize_spaces(m.group(1))
+            if "=" not in candidate:
+                continue
+            if re.search(r"[a-z]", candidate.lower()):
                 return candidate
 
-    eq_index = cleaned.find("=")
-    left = re.findall(r"[A-Za-z0-9\.\+\-\*/\^\(\)\s]+$", cleaned[:eq_index])
-    right = re.findall(r"^[A-Za-z0-9\.\+\-\*/\^\(\)\s]+", cleaned[eq_index + 1:])
-    if left and right:
-        candidate = left[0].strip().split()[-1] + " = " + right[0].strip().split()[0]
-        if re.search(r"[a-z]", candidate.lower()):
-            return candidate
+    # fallback: split once on equals and trim to likely expression zones
+    parts = cleaned.split("=", 1)
+    if len(parts) != 2:
+        return None
+
+    lhs = parts[0].strip(" .,:;!?")
+    rhs = parts[1].strip(" .,:;!?")
+
+    if not lhs or not rhs:
+        return None
+
+    candidate = f"{lhs} = {rhs}"
+    if re.search(r"[a-z]", candidate.lower()):
+        return candidate
+
     return None
 
 
+def _extract_variable_names(expr: str) -> List[str]:
+    # catches x in "3x + 5 = 20" as well as standalone x
+    vars_found = sorted(set(re.findall(r"[a-z]", expr.lower())))
+    # avoid treating common words as many variables by keeping only likely algebra variables first
+    preferred = [v for v in vars_found if v in {"x", "y", "z", "n"}]
+    return preferred or vars_found
+
+
 def _parse_number(text: str) -> Optional[float]:
     raw = clean_math_text(text).strip().lower()
 
@@ -189,7 +225,7 @@ def _solve_successive_percent(text: str) -> Optional[SolverResult]:
         topic="percent",
         answer_value=f"{magnitude:g}%",
         internal_answer=f"net {direction} of {magnitude:g}%",
-        steps=step_lines + [f"The combined multiplier gives a net {direction} of {magnitude:g}%."],
+        steps=step_lines + [f"Combine the multipliers to find the overall percent change."],
         choices_text=text,
     )
 
@@ -226,28 +262,24 @@ def _solve_ratio_total(text: str) -> Optional[SolverResult]:
 
     labels = _extract_ratio_labels(lower)
     requested_value = left_value
-    requested_label = "first quantity"
 
     if labels:
         left_label, right_label = labels
         if left_label in lower and re.search(rf"how many {re.escape(left_label)}", lower):
             requested_value = left_value
-            requested_label = left_label
         elif right_label in lower and re.search(rf"how many {re.escape(right_label)}", lower):
             requested_value = right_value
-            requested_label = right_label
         else:
             requested_value = left_value
-            requested_label = left_label
 
     return _make_result(
         topic="ratio",
         answer_value=f"{requested_value:g}",
-        internal_answer=f"{requested_label} = {requested_value:g}",
+        internal_answer=f"{requested_value:g}",
         steps=[
             f"Add the ratio parts: {a} + {b} = {part_sum}.",
-            f"Each ratio unit is {total} / {part_sum} = {unit:g}.",
-            f"Multiply by the required ratio part to get {requested_value:g}.",
+            f"Find the value of one ratio part using the total.",
+            f"Multiply by the required ratio part.",
         ],
         choices_text=text,
     )
@@ -275,7 +307,7 @@ def _solve_remainder(text: str) -> Optional[SolverResult]:
         internal_answer=str(r),
         steps=[
             f"Divide {a} by {b}.",
-            f"The remainder is {a} mod {b} = {r}.",
+            "Keep the amount left over after division.",
         ],
         choices_text=text,
     )
@@ -285,10 +317,27 @@ def _solve_percent(text: str) -> Optional[SolverResult]:
     lower = clean_math_text(text).lower()
     choices = extract_choices(text)
 
-    m = re.search(r"(\d+(?:\.\d+)?)\s*(?:%|percent)\s+of\s+(?:a\s+)?number\s+is\s+(\d+(?:\.\d+)?)", lower)
-    if m:
-        p = float(m.group(1))
-        value = float(m.group(2))
+    patterns = [
+        r"(\d+(?:\.\d+)?)\s*(?:%|percent)\s+of\s+(?:a\s+)?number\s+is\s+(\d+(?:\.\d+)?)",
+        r"(\d+(?:\.\d+)?)\s*(?:%|percent)\s+of\s+([a-z])\s+is\s+(\d+(?:\.\d+)?)",
+        r"(\d+(?:\.\d+)?)\s*(?:%|percent)\s+of\s+([a-z])\s*=\s*(\d+(?:\.\d+)?)",
+    ]
+
+    for pat in patterns:
+        m = re.search(pat, lower)
+        if not m:
+            continue
+
+        if len(m.groups()) == 2:
+            p = float(m.group(1))
+            value = float(m.group(2))
+        else:
+            p = float(m.group(1))
+            value = float(m.group(3))
+
+        if p == 0:
+            return None
+
         ans = value / (p / 100.0)
         answer_letter = _best_choice(ans, choices) if choices else None
 
@@ -300,9 +349,10 @@ def _solve_percent(text: str) -> Optional[SolverResult]:
             answer_letter=answer_letter,
             internal_answer=f"{ans:g}",
             steps=[
-                "Let the number be n.",
-                f"Write {p}% of n as {p / 100:g}n.",
-                f"Set {p / 100:g}n = {value} and solve for n.",
+                "Let the unknown quantity be a variable.",
+                f"Convert {p:g}% into its decimal form.",
+                "Write an equation for the part and whole relationship.",
+                "Solve that equation for the unknown.",
             ],
         )
 
@@ -321,8 +371,8 @@ def _solve_percent(text: str) -> Optional[SolverResult]:
             answer_letter=answer_letter,
             internal_answer=f"{ans:g}",
             steps=[
-                f"Convert {p}% to {p / 100:g}.",
-                f"Multiply by {n}.",
+                f"Convert {p:g}% to a decimal.",
+                f"Multiply that decimal by {n}.",
             ],
         )
 
@@ -370,16 +420,18 @@ def _solve_linear_equation(text: str) -> Optional[SolverResult]:
 
     try:
         lhs, rhs = expr.split("=", 1)
-        symbols = sorted(set(re.findall(r"\b[a-z]\b", expr)))
+        lhs_prepped = _prepare_expression(lhs)
+        rhs_prepped = _prepare_expression(rhs)
+
+        symbols = _extract_variable_names(expr)
         if not symbols:
             return None
 
         var_name = symbols[0]
         var = sp.symbols(var_name)
-        sol = sp.solve(
-            sp.Eq(sp.sympify(_prepare_expression(lhs)), sp.sympify(_prepare_expression(rhs))),
-            var,
-        )
+
+        equation = sp.Eq(sp.sympify(lhs_prepped), sp.sympify(rhs_prepped))
+        sol = sp.solve(equation, var)
         if not sol:
             return None
 
@@ -401,7 +453,7 @@ def _solve_linear_equation(text: str) -> Optional[SolverResult]:
             steps=[
                 "Treat the statement as an equation.",
                 "Undo operations on both sides to isolate the variable.",
-                f"That gives {var_name} = {value}.",
+                "Keep simplifying until the variable is alone.",
             ],
         )
     except Exception: