Create quant_solver.py

quant_solver.py

@@ -0,0 +1,470 @@
+from __future__ import annotations
+
+import math
+import re
+from statistics import mean, median
+from typing import Dict, List, Optional
+
+from models import SolverResult
+from utils import clean_math_text, normalize_spaces
+
+try:
+    import sympy as sp
+except Exception:
+    sp = None
+
+
+CHOICE_LETTERS = ["A", "B", "C", "D", "E"]
+
+
+def has_answer_choices(text: str) -> bool:
+    patterns = [
+        r"\bA[\)\.\:]",
+        r"\bB[\)\.\:]",
+        r"\bC[\)\.\:]",
+        r"\bD[\)\.\:]",
+        r"\bE[\)\.\:]",
+    ]
+    return sum(bool(re.search(p, text, flags=re.I)) for p in patterns) >= 3
+
+
+def extract_choices(text: str) -> Dict[str, str]:
+    matches = list(
+        re.finditer(
+            r"(?im)(?:^|\n|\s)([A-E])[\)\.\:]\s*(.*?)(?=(?:\n?\s*[A-E][\)\.\:]\s)|$)",
+            text,
+        )
+    )
+    choices: Dict[str, str] = {}
+    for m in matches:
+        letter = m.group(1).upper()
+        content = normalize_spaces(m.group(2))
+        choices[letter] = content
+    return choices
+
+
+def extract_numbers(text: str) -> List[float]:
+    nums = re.findall(r"-?\d+(?:\.\d+)?", text.replace(",", ""))
+    out: List[float] = []
+    for n in nums:
+        try:
+            out.append(float(n))
+        except Exception:
+            pass
+    return out
+
+
+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"
+    ]
+    if any(k in lower for k in quant_keywords):
+        return True
+    if re.search(r"[0-9]", text) and ("?" in text or has_answer_choices(text)):
+        return True
+    return False
+
+
+def try_eval_expression(expr: str) -> Optional[float]:
+    expr = clean_math_text(expr)
+    expr = expr.strip()
+    expr = expr.replace("%", "/100")
+    expr = re.sub(r"[^0-9\.\+\-\*\/\(\)\s]", "", expr)
+
+    if not expr:
+        return None
+
+    try:
+        return float(eval(expr, {"__builtins__": {}}, {}))
+    except Exception:
+        return None
+
+
+def parse_direct_expression_question(text: str) -> Optional[str]:
+    lower = text.lower()
+    m = re.search(
+        r"(?:what is|calculate|compute|evaluate|find)\s+([0-9\.\+\-\*\/\(\)\s]+)\??",
+        lower,
+    )
+    if not m:
+        return None
+    expr = m.group(1).strip()
+    if len(expr) < 1:
+        return None
+    return expr
+
+
+def solve_basic_expression(text: str, help_mode: str) -> Optional[SolverResult]:
+    expr = parse_direct_expression_question(text)
+    if not expr:
+        return None
+
+    value = try_eval_expression(expr)
+    if value is None:
+        return None
+
+    if help_mode == "hint":
+        reply = "Focus on order of operations: parentheses, multiplication/division, then addition/subtraction."
+    elif help_mode == "walkthrough":
+        reply = f"Evaluate the expression {expr} using order of operations.\nThat gives {value:g}."
+    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}")
+
+
+def solve_percent_question(text: str, help_mode: str) -> Optional[SolverResult]:
+    lower = text.lower()
+
+    m = re.search(r"what is\s+(\d+(?:\.\d+)?)\s*%\s+of\s+(\d+(?:\.\d+)?)", lower)
+    if m:
+        p = float(m.group(1))
+        n = float(m.group(2))
+        ans = p / 100 * n
+
+        if help_mode == "hint":
+            reply = "Convert the percent to a decimal, then multiply."
+        elif help_mode == "walkthrough":
+            reply = f"{p}% of {n} = {p/100:g} × {n} = {ans:g}."
+        else:
+            reply = f"The answer is {ans:g}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
+
+    m = re.search(r"(\d+(?:\.\d+)?)\s+is\s+what percent of\s+(\d+(?:\.\d+)?)", lower)
+    if m:
+        x = float(m.group(1))
+        y = float(m.group(2))
+        if y == 0:
+            return None
+
+        ans = x / y * 100
+
+        if help_mode == "hint":
+            reply = "Use part ÷ whole × 100."
+        elif help_mode == "walkthrough":
+            reply = f"Percent = ({x} / {y}) × 100 = {ans:g}%."
+        else:
+            reply = f"The answer is {ans:g}%."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}%")
+
+    m = re.search(
+        r"(\d+(?:\.\d+)?)\s+(?:is\s+)?(increased|decreased)\s+by\s+(\d+(?:\.\d+)?)\s*%",
+        lower,
+    )
+    if m:
+        base = float(m.group(1))
+        direction = m.group(2)
+        p = float(m.group(3)) / 100
+        ans = base * (1 + p) if direction == "increased" else base * (1 - p)
+
+        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}."
+        else:
+            reply = f"The result is {ans:g}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
+
+    return None
+
+
+def solve_ratio_question(text: str, help_mode: str) -> Optional[SolverResult]:
+    lower = text.lower()
+
+    m = re.search(
+        r"ratio of .*? is\s+(\d+)\s*:\s*(\d+).*?total (?:is|of)\s+(\d+(?:\.\d+)?)",
+        lower
+    )
+    if not m:
+        m = re.search(
+            r"(\d+)\s*:\s*(\d+).*?total (?:is|of)\s+(\d+(?:\.\d+)?)",
+            lower
+        )
+
+    if m:
+        a = float(m.group(1))
+        b = float(m.group(2))
+        total = float(m.group(3))
+        parts = a + b
+        if parts == 0:
+            return None
+
+        first = total * a / parts
+        second = total * b / parts
+
+        if help_mode == "hint":
+            reply = "Add the ratio parts, then convert each part into a fraction of the total."
+        elif help_mode == "walkthrough":
+            reply = (
+                f"Total parts = {a:g} + {b:g} = {parts:g}.\n"
+                f"First quantity = {a:g}/{parts:g} × {total:g} = {first:g}.\n"
+                f"Second quantity = {b:g}/{parts:g} × {total:g} = {second:g}."
+            )
+        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 None
+
+
+def solve_average_question(text: str, help_mode: str) -> Optional[SolverResult]:
+    lower = text.lower()
+
+    if "mean" in lower or "average" in lower:
+        nums = extract_numbers(text)
+        if len(nums) >= 2:
+            ans = mean(nums)
+
+            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}."
+            else:
+                reply = f"The average is {ans:g}."
+
+            return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
+
+    if "median" in lower:
+        nums = extract_numbers(text)
+        if len(nums) >= 2:
+            ans = median(nums)
+
+            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}."
+            else:
+                reply = f"The median is {ans:g}."
+
+            return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
+
+    return None
+
+
+def solve_probability_question(text: str, help_mode: str) -> Optional[SolverResult]:
+    lower = text.lower()
+
+    m = re.search(r"(\d+)\s+red.*?(\d+)\s+blue.*?probability", lower)
+    if m:
+        r = float(m.group(1))
+        b = float(m.group(2))
+        total = r + b
+        if total == 0:
+            return None
+
+        ans = r / total
+
+        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}."
+        else:
+            reply = f"The probability is {ans:g}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
+
+    return None
+
+
+def solve_geometry_question(text: str, help_mode: str) -> Optional[SolverResult]:
+    lower = text.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
+
+        if help_mode == "hint":
+            reply = "For a rectangle, area = length × width."
+        elif help_mode == "walkthrough":
+            reply = f"Area = {l:g} × {w:g} = {ans:g}."
+        else:
+            reply = f"The area is {ans:g}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, 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
+
+        if help_mode == "hint":
+            reply = "For a circle, area = πr²."
+        elif help_mode == "walkthrough":
+            reply = f"Area = π({r:g})² = {ans:.4f}."
+        else:
+            reply = f"The area is {ans:.4f}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:.4f}")
+
+    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
+
+        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}."
+        else:
+            reply = f"The area is {ans:g}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
+
+    return None
+
+
+def solve_linear_equation(text: str, help_mode: str) -> Optional[SolverResult]:
+    if sp is None:
+        return None
+
+    lower = text.lower().replace("^", "**")
+
+    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:
+            return None
+
+    eq_text = m.group(1).strip()
+    eq_text = re.sub(r"(\d)([a-z])", r"\1*\2", eq_text)
+    eq_text = re.sub(r"([a-z])(\d)", r"\1*\2", eq_text)
+
+    parts = eq_text.split("=")
+    if len(parts) != 2:
+        return None
+
+    try:
+        x = sp.symbols("x")
+        left = sp.sympify(parts[0])
+        right = sp.sympify(parts[1])
+        sols = sp.solve(sp.Eq(left, right), x)
+        if not sols:
+            return None
+
+        sol = sols[0]
+
+        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)}."
+        else:
+            reply = f"x = {sp.simplify(sol)}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=str(sp.simplify(sol)))
+    except Exception:
+        return None
+
+
+def compare_to_choices_numeric(answer_value: float, choices: Dict[str, str]) -> Optional[str]:
+    best_letter = None
+    best_diff = float("inf")
+
+    for letter, raw in choices.items():
+        expr = raw.strip()
+        expr_val = try_eval_expression(expr)
+
+        if expr_val is None:
+            nums = extract_numbers(expr)
+            if len(nums) == 1:
+                expr_val = nums[0]
+
+        if expr_val is None:
+            continue
+
+        diff = abs(expr_val - answer_value)
+        if diff < best_diff:
+            best_diff = diff
+            best_letter = letter
+
+    return best_letter
+
+
+def solve_by_option_checking(text: str, help_mode: str) -> Optional[SolverResult]:
+    choices = extract_choices(text)
+    if len(choices) < 3:
+        return None
+
+    expr = parse_direct_expression_question(text)
+    if expr:
+        val = try_eval_expression(expr)
+        if val is not None:
+            letter = compare_to_choices_numeric(val, choices)
+            if letter:
+                if help_mode == "hint":
+                    reply = "Evaluate the expression first, then match it to the answer choices."
+                elif help_mode == "walkthrough":
+                    reply = f"The expression evaluates to {val:g}, which matches choice {letter}."
+                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}")
+
+    lower = text.lower()
+    m = re.search(r"what is\s+(\d+(?:\.\d+)?)\s*%\s+of\s+(\d+(?:\.\d+)?)", lower)
+    if m:
+        val = float(m.group(1)) / 100 * float(m.group(2))
+        letter = compare_to_choices_numeric(val, choices)
+        if letter:
+            if help_mode == "hint":
+                reply = "Compute the percentage, then match it to the options."
+            elif help_mode == "walkthrough":
+                reply = f"{m.group(1)}% of {m.group(2)} = {val:g}, so the correct choice is {letter}."
+            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 None
+
+
+def solve_quant(text: str, help_mode: str) -> SolverResult:
+    solvers = [
+        solve_by_option_checking,
+        solve_basic_expression,
+        solve_percent_question,
+        solve_ratio_question,
+        solve_average_question,
+        solve_probability_question,
+        solve_geometry_question,
+        solve_linear_equation,
+    ]
+
+    for solver in solvers:
+        try:
+            out = solver(text, help_mode)
+            if out:
+                return out
+        except Exception:
+            pass
+
+    if help_mode == "hint":
+        reply = (
+            "Identify the question type first: arithmetic, percent, ratio, algebra, probability, "
+            "statistics, or geometry. Then extract the given numbers and set up the core relation."
+        )
+    elif help_mode == "walkthrough":
+        reply = (
+            "I can help with this, but I cannot confidently solve it from the current parse alone. "
+            "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)