Update quant_solver.py

quant_solver.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import math
 import re
+from fractions import Fraction
 from statistics import mean, median
 from typing import Dict, List, Optional
 
@@ -62,7 +63,7 @@ def is_quant_question(text: str) -> bool:
         "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"
+        "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
@@ -100,6 +101,49 @@ 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]:
+    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
+
+    if best_diff <= tolerance or best_letter is not None:
+        return best_letter
+    return None
+
+
+def compare_fraction_to_choices(fraction_text: str, choices: Dict[str, str]) -> Optional[str]:
+    target = fraction_text.strip()
+
+    for letter, raw in choices.items():
+        value = raw.strip().replace(" ", "")
+        if value == target.replace(" ", ""):
+            return letter
+
+        m = re.match(r"^(\d+)\s*/\s*(\d+)$", value)
+        if m:
+            cand = f"{int(m.group(1))}/{int(m.group(2))}"
+            if cand == target:
+                return letter
+
+    return None
+
+
 def solve_basic_expression(text: str, help_mode: str) -> Optional[SolverResult]:
     expr = parse_direct_expression_question(text)
     if not expr:
@@ -121,22 +165,37 @@ def solve_basic_expression(text: str, help_mode: str) -> Optional[SolverResult]:
 
 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))
         n = float(m.group(2))
         ans = p / 100 * n
+        letter = compare_to_choices_numeric(ans, choices) if choices else None
 
         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}."
+            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_letter=letter,
+            answer_value=f"{ans:g}",
+        )
 
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, 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))
@@ -155,6 +214,39 @@ def solve_percent_question(text: str, help_mode: str) -> Optional[SolverResult]:
 
         return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, 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)
+
+    if m:
+        p = float(m.group(1))
+        if p.is_integer():
+            frac = Fraction(int(p), 100)
+            fraction_text = f"{frac.numerator}/{frac.denominator}"
+            letter = compare_fraction_to_choices(fraction_text, choices) if choices else None
+
+            if help_mode == "hint":
+                reply = "Think of percent as 'out of 100', then simplify the fraction."
+            elif help_mode == "walkthrough":
+                reply = f"{int(p)}% = {int(p)}/100 = {fraction_text}."
+                if letter:
+                    reply += f"\nThat matches choice {letter}."
+            else:
+                reply = f"{int(p)}% = {fraction_text}."
+                if letter:
+                    reply += f" So the correct choice is {letter}."
+
+            return SolverResult(
+                reply=reply,
+                domain="quant",
+                solved=True,
+                help_mode=help_mode,
+                answer_letter=letter,
+                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,
@@ -280,6 +372,48 @@ def solve_probability_question(text: str, help_mode: str) -> Optional[SolverResu
 
 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,
+    )
+    if m and "width" in lower:
+        p = float(m.group(1))
+        l = float(m.group(2))
+        ans = p / 2 - l
+        letter = compare_to_choices_numeric(ans, choices) if choices else None
+
+        if help_mode == "hint":
+            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"
+                f"So W = {ans:g}."
+            )
+            if letter:
+                reply += f"\nThat matches choice {letter}."
+        else:
+            reply = f"The width 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_letter=letter,
+            answer_value=f"{ans:g}",
+        )
 
     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:
@@ -328,6 +462,50 @@ def solve_geometry_question(text: str, help_mode: str) -> Optional[SolverResult]
     return None
 
 
+def solve_divisibility_question(text: str, help_mode: str) -> Optional[SolverResult]:
+    lower = text.lower()
+    choices = extract_choices(text)
+
+    if "divisible by 5" in lower and "3x+2" in lower.replace(" ", ""):
+        valid_letter = None
+        valid_x = None
+
+        for letter, raw in choices.items():
+            nums = extract_numbers(raw)
+            if len(nums) != 1:
+                continue
+            x = int(nums[0])
+            if (3 * x + 2) % 5 == 0:
+                valid_letter = letter
+                valid_x = x
+                break
+
+        if valid_x is None:
+            return None
+
+        if help_mode == "hint":
+            reply = "Test the answer choices in 3x + 2 and see which makes a multiple of 5."
+        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"So the correct choice is {valid_letter}."
+            )
+        else:
+            reply = f"x = {valid_x}, so the correct choice is {valid_letter}."
+
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=True,
+            help_mode=help_mode,
+            answer_letter=valid_letter,
+            answer_value=str(valid_x),
+        )
+
+    return None
+
+
 def solve_linear_equation(text: str, help_mode: str) -> Optional[SolverResult]:
     if sp is None:
         return None
@@ -370,30 +548,6 @@ def solve_linear_equation(text: str, help_mode: str) -> Optional[SolverResult]:
         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:
@@ -440,6 +594,7 @@ def solve_quant(text: str, help_mode: str) -> SolverResult:
         solve_average_question,
         solve_probability_question,
         solve_geometry_question,
+        solve_divisibility_question,
         solve_linear_equation,
         solve_basic_expression,
     ]
@@ -454,8 +609,8 @@ def solve_quant(text: str, help_mode: str) -> SolverResult:
 
     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."
+            "Identify the question type first, then use the key relationship or formula. "
+            "If there are answer choices, you can also test them directly."
         )
     elif help_mode == "walkthrough":
         reply = (