Update solver_percent.py

solver_percent.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import math
 import re
 from typing import Optional, List
 
@@ -10,180 +11,586 @@ def _nums(text: str) -> List[float]:
     return [float(x) for x in re.findall(r"-?\d+(?:\.\d+)?", text)]
 
 
+def _clean(text: str) -> str:
+    return re.sub(r"\s+", " ", (text or "").strip()).lower()
+
+
+def _pct_to_decimal(p: float) -> float:
+    return p / 100.0
+
+
+def _safe_fmt(x: float) -> str:
+    return f"{x:g}"
+
+
+def _build_result(
+    *,
+    topic: str,
+    internal_answer: Optional[float] = None,
+    ask: str,
+    given: str,
+    method: List[str],
+) -> SolverResult:
+    return SolverResult(
+        domain="quant",
+        solved=True,
+        topic=topic,
+        answer_value=None,          # never expose final answer
+        internal_answer=_safe_fmt(internal_answer) if internal_answer is not None else None,
+        steps=[
+            f"What the question is asking: {ask}",
+            f"What is given: {given}",
+            *method,
+        ],
+    )
+
+
+def _fallback_percent() -> SolverResult:
+    return SolverResult(
+        domain="quant",
+        solved=False,
+        topic="percent",
+        answer_value=None,
+        internal_answer=None,
+        steps=[
+            "What the question is asking: identify whether you need the part, the whole, the percent, or the percent change.",
+            "Key relationships:",
+            "• part = percent × whole",
+            "• percent = part ÷ whole × 100",
+            "• percent change = change ÷ original × 100",
+            "Start by labeling the numbers in the problem as original, new, part, whole, rate, or time.",
+        ],
+    )
+
+
 def solve_percent(text: str) -> Optional[SolverResult]:
-    lower = (text or "").lower()
+    raw = text or ""
+    lower = _clean(raw)
 
-    if "%" not in lower and "percent" not in lower:
+    percent_words = [
+        "%", "percent", "percentage", "pct",
+        "increase", "decrease", "discount", "markup",
+        "profit", "loss", "interest", "percentile",
+        "tax", "tip", "sale"
+    ]
+    if not any(w in lower for w in percent_words):
         return None
 
     nums = _nums(lower)
 
-    # Pattern 1: "40% of a number is 24"
+    # --------------------------------------------------
+    # 1) BASIC PART: "What is 25% of 80?"
+    # --------------------------------------------------
     m = re.search(
-        r"(\d+(?:\.\d+)?)\s*%?\s*(?:percent)?\s*of\s+(?:a\s+number|number|x|an?\s+amount).*?\bis\b\s*(-?\d+(?:\.\d+)?)",
-        lower,
+        r"what\s+is\s+(\d+(?:\.\d+)?)\s*(?:%|percent|pct)?\s+of\s+(-?\d+(?:\.\d+)?)",
+        lower
     )
     if m:
-        pct = float(m.group(1)) / 100.0
-        value = float(m.group(2))
-        if pct == 0:
-            return None
-        result = value / pct
-        return SolverResult(
-            domain="quant",
-            solved=True,
+        pct = float(m.group(1))
+        whole = float(m.group(2))
+        result = _pct_to_decimal(pct) * whole
+        return _build_result(
             topic="percent",
-            answer_value=f"{result:g}",
-            internal_answer=f"{result:g}",
-            steps=[
+            internal_answer=result,
+            ask="Find the part when the percent and whole are known.",
+            given=f"percent = {pct}%, whole = {whole}",
+            method=[
                 "Convert the percent to a decimal.",
-                "Set up percent × whole = part.",
-                "Divide the part by the decimal percent to get the whole.",
+                "Use part = percent × whole.",
+                "Multiply the decimal percent by the whole.",
             ],
         )
 
-    # Pattern 2: "What is 25% of 80?"
+    # --------------------------------------------------
+    # 2) BASIC WHOLE: "40% of a number is 24"
+    #    Also handles "60 is 25% of what number?"
+    # --------------------------------------------------
     m = re.search(
-        r"what\s+is\s+(\d+(?:\.\d+)?)\s*%?\s*(?:percent)?\s*of\s*(-?\d+(?:\.\d+)?)",
-        lower,
+        r"(\d+(?:\.\d+)?)\s*(?:%|percent|pct)\s+of\s+(?:a\s+number|number|what\s+number|x|y|an?\s+amount|the\s+number).*?\bis\s+(-?\d+(?:\.\d+)?)",
+        lower
     )
     if m:
-        pct = float(m.group(1)) / 100.0
-        whole = float(m.group(2))
-        result = pct * whole
-        return SolverResult(
-            domain="quant",
-            solved=True,
+        pct = float(m.group(1))
+        part = float(m.group(2))
+        dec = _pct_to_decimal(pct)
+        if dec == 0:
+            return _fallback_percent()
+        result = part / dec
+        return _build_result(
             topic="percent",
-            answer_value=f"{result:g}",
-            internal_answer=f"{result:g}",
-            steps=[
+            internal_answer=result,
+            ask="Find the whole when the percent and part are known.",
+            given=f"percent = {pct}%, part = {part}",
+            method=[
                 "Convert the percent to a decimal.",
-                "Multiply the whole by the decimal percent.",
+                "Use part = percent × whole.",
+                "Rearrange to whole = part ÷ percent.",
+            ],
+        )
+
+    m = re.search(
+        r"(-?\d+(?:\.\d+)?)\s+is\s+(\d+(?:\.\d+)?)\s*(?:%|percent|pct)\s+of\s+(?:what|which)\s+(?:number|value|amount)",
+        lower
+    )
+    if m:
+        part = float(m.group(1))
+        pct = float(m.group(2))
+        dec = _pct_to_decimal(pct)
+        if dec == 0:
+            return _fallback_percent()
+        result = part / dec
+        return _build_result(
+            topic="percent",
+            internal_answer=result,
+            ask="Find the original whole from a known part and percent.",
+            given=f"part = {part}, percent = {pct}%",
+            method=[
+                "Convert the percent to decimal form.",
+                "Use part = percent × whole.",
+                "Solve for the whole by dividing the part by the decimal percent.",
             ],
         )
 
-    # Pattern 3: "24 is what percent of 60?"
+    # --------------------------------------------------
+    # 3) WHAT PERCENT: "24 is what percent of 60?"
+    # --------------------------------------------------
     m = re.search(
-        r"(-?\d+(?:\.\d+)?)\s+is\s+what\s+percent\s+of\s+(-?\d+(?:\.\d+)?)",
-        lower,
+        r"(-?\d+(?:\.\d+)?)\s+is\s+what\s+(?:%|percent|percentage)\s+of\s+(-?\d+(?:\.\d+)?)",
+        lower
     )
     if m:
         part = float(m.group(1))
         whole = float(m.group(2))
         if whole == 0:
-            return None
-        result = (part / whole) * 100
-        return SolverResult(
-            domain="quant",
-            solved=True,
+            return _fallback_percent()
+        result = (part / whole) * 100.0
+        return _build_result(
             topic="percent",
-            answer_value=f"{result:g}",
-            internal_answer=f"{result:g}",
-            steps=[
+            internal_answer=result,
+            ask="Find what percent one value is of another.",
+            given=f"part = {part}, whole = {whole}",
+            method=[
                 "Use percent = part ÷ whole × 100.",
                 "Divide the part by the whole.",
-                "Convert the decimal to a percent.",
+                "Convert the result to percent form.",
             ],
         )
 
-    # Pattern 4: "What percent of 60 is 24?"
     m = re.search(
-        r"what\s+percent\s+of\s+(-?\d+(?:\.\d+)?)\s+is\s+(-?\d+(?:\.\d+)?)",
-        lower,
+        r"what\s+(?:%|percent|percentage)\s+of\s+(-?\d+(?:\.\d+)?)\s+is\s+(-?\d+(?:\.\d+)?)",
+        lower
     )
     if m:
         whole = float(m.group(1))
         part = float(m.group(2))
         if whole == 0:
-            return None
-        result = (part / whole) * 100
-        return SolverResult(
-            domain="quant",
-            solved=True,
+            return _fallback_percent()
+        result = (part / whole) * 100.0
+        return _build_result(
             topic="percent",
-            answer_value=f"{result:g}",
-            internal_answer=f"{result:g}",
-            steps=[
+            internal_answer=result,
+            ask="Find the percent represented by the part out of the whole.",
+            given=f"whole = {whole}, part = {part}",
+            method=[
                 "Use percent = part ÷ whole × 100.",
                 "Divide the part by the whole.",
-                "Convert to percent form.",
+                "Then convert to a percent.",
             ],
         )
 
-    # Pattern 5: percent increase/decrease
+    # --------------------------------------------------
+    # 4) PERCENT CHANGE: "from 80 to 60"
+    # --------------------------------------------------
     m = re.search(
-        r"(-?\d+(?:\.\d+)?)\s*%?\s*(?:percent)?\s*(increase|decrease)[sd]?\s+from\s+(-?\d+(?:\.\d+)?)\s+to\s+(-?\d+(?:\.\d+)?)",
-        lower,
+        r"(?:what\s+(?:is\s+the\s+)?)?(?:percent\s+)?(increase|decrease|change).*?from\s+(-?\d+(?:\.\d+)?)\s+to\s+(-?\d+(?:\.\d+)?)",
+        lower
     )
     if m:
-        # rare wording, not ideal
-        pass
+        direction = m.group(1)
+        old = float(m.group(2))
+        new = float(m.group(3))
+        if old == 0:
+            return _fallback_percent()
+        result = ((new - old) / old) * 100.0
+        return _build_result(
+            topic="percent_change",
+            internal_answer=abs(result) if direction in ("increase", "decrease") else result,
+            ask="Find the percent change relative to the original value.",
+            given=f"original = {old}, new = {new}",
+            method=[
+                "Find the change: new − original.",
+                "Use the original value in the denominator.",
+                "Compute change ÷ original × 100.",
+                "Match the sign or wording to increase vs decrease.",
+            ],
+        )
 
     m = re.search(
-        r"(?:increase|decrease)[sd]?\s+from\s+(-?\d+(?:\.\d+)?)\s+to\s+(-?\d+(?:\.\d+)?)",
-        lower,
+        r"from\s+(-?\d+(?:\.\d+)?)\s+to\s+(-?\d+(?:\.\d+)?)",
+        lower
     )
     if m and ("percent" in lower or "%" in lower):
         old = float(m.group(1))
         new = float(m.group(2))
         if old == 0:
-            return None
-        result = ((new - old) / old) * 100
-        return SolverResult(
-            domain="quant",
-            solved=True,
+            return _fallback_percent()
+        result = ((new - old) / old) * 100.0
+        return _build_result(
             topic="percent_change",
-            answer_value=f"{result:g}",
-            internal_answer=f"{result:g}",
-            steps=[
-                "Find the change: new − old.",
-                "Divide by the original value.",
-                "Multiply by 100 to convert to a percent.",
+            internal_answer=result,
+            ask="Find the percent change between the starting value and ending value.",
+            given=f"original = {old}, new = {new}",
+            method=[
+                "Subtract to find the change.",
+                "Divide by the original value, not the new value.",
+                "Multiply by 100 to convert to percent form.",
             ],
         )
 
-    # Pattern 6: "increased by 20%" / "decreased by 20%"
+    # --------------------------------------------------
+    # 5) NEW VALUE AFTER CHANGE: "80 increased by 25%"
+    # --------------------------------------------------
     m = re.search(
-        r"(-?\d+(?:\.\d+)?)\s+(?:is\s+)?(increased|decreased)\s+by\s+(\d+(?:\.\d+)?)\s*%",
-        lower,
+        r"(-?\d+(?:\.\d+)?)\s+(?:is\s+)?(increased|decreased|reduced)\s+by\s+(\d+(?:\.\d+)?)\s*%",
+        lower
     )
     if m:
-        value = float(m.group(1))
+        original = float(m.group(1))
         direction = m.group(2)
-        pct = float(m.group(3)) / 100.0
-        result = value * (1 + pct if direction == "increased" else 1 - pct)
-        return SolverResult(
-            domain="quant",
-            solved=True,
+        pct = float(m.group(3))
+        dec = _pct_to_decimal(pct)
+        multiplier = 1 + dec if direction == "increased" else 1 - dec
+        result = original * multiplier
+        return _build_result(
             topic="percent_change",
-            answer_value=f"{result:g}",
-            internal_answer=f"{result:g}",
-            steps=[
+            internal_answer=result,
+            ask="Find the new value after a percent increase or decrease.",
+            given=f"original = {original}, change = {pct}% {direction}",
+            method=[
                 "Convert the percent to a decimal.",
-                "Use multiplier 1 + p for increase or 1 − p for decrease.",
-                "Multiply the original value by that multiplier.",
+                "Use a multiplier.",
+                "For increase, multiply by 1 + p.",
+                "For decrease, multiply by 1 − p.",
+            ],
+        )
+
+    # --------------------------------------------------
+    # 6) ORIGINAL BEFORE CHANGE:
+    #    "After a 20% increase, a number is 120"
+    #    "After a 25% discount, the price is 90"
+    # --------------------------------------------------
+    m = re.search(
+        r"after\s+(?:an?\s+)?(\d+(?:\.\d+)?)\s*%\s*(increase|decrease|discount|markup|reduction|loss|gain).*?(?:is|becomes|equals|was|now\s+is)\s+(-?\d+(?:\.\d+)?)",
+        lower
+    )
+    if m:
+        pct = float(m.group(1))
+        kind = m.group(2)
+        final_value = float(m.group(3))
+        dec = _pct_to_decimal(pct)
+
+        if kind in ("increase", "markup", "gain"):
+            multiplier = 1 + dec
+        else:
+            multiplier = 1 - dec
+
+        if multiplier == 0:
+            return _fallback_percent()
+
+        result = final_value / multiplier
+        return _build_result(
+            topic="reverse_percent",
+            internal_answer=result,
+            ask="Find the original value before a percent change.",
+            given=f"final value = {final_value}, change = {pct}% {kind}",
+            method=[
+                "Translate the percent change into a multiplier.",
+                "Increase/markup/gain → original × (1 + p).",
+                "Decrease/discount/loss → original × (1 − p).",
+                "Solve by dividing the final value by that multiplier.",
             ],
         )
 
-    # Pattern 7: percent error / generic part-whole if 2 nums and clue words
-    if len(nums) >= 2 and ("of" in lower or "is" in lower):
-        # conservative fallback
-        pct = nums[0]
-        whole = nums[1]
-        if pct <= 100:
-            result = (pct / 100.0) * whole
-            return SolverResult(
-                domain="quant",
-                solved=True,
-                topic="percent",
-                answer_value=f"{result:g}",
-                internal_answer=f"{result:g}",
-                steps=[
-                    "Interpret the first number as a percent.",
-                    "Convert it to a decimal.",
-                    "Multiply by the base quantity.",
+    # --------------------------------------------------
+    # 7) PERCENT GREATER / LESS THAN
+    #    "What percent greater is 80 than 50?"
+    #    "80 is what percent greater than 50?"
+    # --------------------------------------------------
+    m = re.search(
+        r"what\s+percent\s+(greater|less)\s+(?:is\s+)?(-?\d+(?:\.\d+)?)\s+than\s+(-?\d+(?:\.\d+)?)",
+        lower
+    )
+    if m:
+        relation = m.group(1)
+        a = float(m.group(2))
+        b = float(m.group(3))
+        if b == 0:
+            return _fallback_percent()
+        result = ((a - b) / b) * 100.0
+        return _build_result(
+            topic="percent_comparison",
+            internal_answer=abs(result),
+            ask=f"Compare one value to another and express the difference as a percent of the reference value.",
+            given=f"compare {a} to reference {b}",
+            method=[
+                "Find the difference between the two values.",
+                "Use the second value as the reference base.",
+                "Compute difference ÷ reference × 100.",
+                f"Interpret the result as percent {relation}.",
+            ],
+        )
+
+    m = re.search(
+        r"(-?\d+(?:\.\d+)?)\s+is\s+what\s+percent\s+(greater|less)\s+than\s+(-?\d+(?:\.\d+)?)",
+        lower
+    )
+    if m:
+        a = float(m.group(1))
+        relation = m.group(2)
+        b = float(m.group(3))
+        if b == 0:
+            return _fallback_percent()
+        result = ((a - b) / b) * 100.0
+        return _build_result(
+            topic="percent_comparison",
+            internal_answer=abs(result),
+            ask="Find by what percent one value is greater or less than another.",
+            given=f"value = {a}, reference = {b}",
+            method=[
+                "Subtract to find the difference.",
+                "Divide by the reference value named after 'than'.",
+                "Multiply by 100 to get the percent comparison.",
+                f"Use the wording to label it as {relation}.",
+            ],
+        )
+
+    # --------------------------------------------------
+    # 8) DISCOUNT / MARKUP / TAX / TIP
+    # --------------------------------------------------
+    m = re.search(
+        r"(?:price|cost|bill|amount)\s+of\s+(-?\d+(?:\.\d+)?)\s+.*?(discount|markup|tax|tip)\s+of\s+(\d+(?:\.\d+)?)\s*%",
+        lower
+    )
+    if m:
+        base = float(m.group(1))
+        kind = m.group(2)
+        pct = float(m.group(3))
+        dec = _pct_to_decimal(pct)
+
+        if kind == "discount":
+            result = base * (1 - dec)
+        else:
+            result = base * (1 + dec)
+
+        return _build_result(
+            topic="percent_application",
+            internal_answer=result,
+            ask=f"Apply a {kind} percentage to a base amount.",
+            given=f"base = {base}, rate = {pct}% {kind}",
+            method=[
+                "Convert the percent to decimal form.",
+                "For discount, subtract the percent part from the base or multiply by 1 − p.",
+                "For markup, tax, or tip, add the percent part or multiply by 1 + p.",
+            ],
+        )
+
+    # --------------------------------------------------
+    # 9) PROFIT / LOSS
+    # --------------------------------------------------
+    m = re.search(
+        r"(?:cost price|cp|cost)\s+(-?\d+(?:\.\d+)?)\s+.*?(?:selling price|sp|sold for)\s+(-?\d+(?:\.\d+)?)",
+        lower
+    )
+    if m and ("profit" in lower or "loss" in lower or "percent" in lower or "%" in lower):
+        cost = float(m.group(1))
+        sell = float(m.group(2))
+        if cost == 0:
+            return _fallback_percent()
+        result = ((sell - cost) / cost) * 100.0
+        return _build_result(
+            topic="profit_loss",
+            internal_answer=result,
+            ask="Find the profit or loss percent relative to the cost price.",
+            given=f"cost price = {cost}, selling price = {sell}",
+            method=[
+                "Find profit/loss = selling price − cost price.",
+                "Use cost price as the denominator.",
+                "Compute (profit or loss) ÷ cost price × 100.",
+            ],
+        )
+
+    # --------------------------------------------------
+    # 10) SUCCESSIVE PERCENT CHANGES
+    #     "increased by 20% and then decreased by 10%"
+    # --------------------------------------------------
+    m = re.search(
+        r"(-?\d+(?:\.\d+)?)\s+.*?(increase(?:d)?|decrease(?:d)?|reduced)\s+by\s+(\d+(?:\.\d+)?)\s*%.*?(increase(?:d)?|decrease(?:d)?|reduced)\s+by\s+(\d+(?:\.\d+)?)\s*%",
+        lower
+    )
+    if m:
+        original = float(m.group(1))
+        op1 = m.group(2)
+        p1 = _pct_to_decimal(float(m.group(3)))
+        op2 = m.group(4)
+        p2 = _pct_to_decimal(float(m.group(5)))
+
+        mult1 = 1 + p1 if "increase" in op1 else 1 - p1
+        mult2 = 1 + p2 if "increase" in op2 else 1 - p2
+        result = original * mult1 * mult2
+
+        return _build_result(
+            topic="successive_percent_change",
+            internal_answer=result,
+            ask="Apply two percent changes in sequence.",
+            given=f"start = {original}, first change = {m.group(3)}%, second change = {m.group(5)}%",
+            method=[
+                "Convert each percent to a decimal.",
+                "Turn each change into a multiplier.",
+                "Apply the first multiplier, then apply the second to the new value.",
+                "Do not add or subtract the percentages directly unless the problem specifically asks for net rate in a special setup.",
+            ],
+        )
+
+    # --------------------------------------------------
+    # 11) PERCENT DIFFERENCE
+    # --------------------------------------------------
+    if "percent difference" in lower:
+        m = re.search(
+            r"between\s+(-?\d+(?:\.\d+)?)\s+and\s+(-?\d+(?:\.\d+)?)",
+            lower
+        )
+        if m:
+            a = float(m.group(1))
+            b = float(m.group(2))
+            avg = (a + b) / 2.0
+            if avg == 0:
+                return _fallback_percent()
+            result = abs(a - b) / avg * 100.0
+            return _build_result(
+                topic="percent_difference",
+                internal_answer=result,
+                ask="Find the percent difference between two values.",
+                given=f"values = {a} and {b}",
+                method=[
+                    "Find the absolute difference between the two values.",
+                    "Find the average of the two values.",
+                    "Use percent difference = difference ÷ average × 100.",
+                    "Keep this separate from percent change, which uses the original value as the denominator.",
+                ],
+            )
+
+    # --------------------------------------------------
+    # 12) SIMPLE INTEREST
+    # --------------------------------------------------
+    if "simple interest" in lower:
+        m = re.search(
+            r"(-?\d+(?:\.\d+)?)\s+.*?(\d+(?:\.\d+)?)\s*%\s+.*?(\d+(?:\.\d+)?)\s*(year|years|month|months)",
+            lower
+        )
+        if m:
+            principal = float(m.group(1))
+            rate = float(m.group(2))
+            time = float(m.group(3))
+            unit = m.group(4)
+
+            t_years = time / 12.0 if "month" in unit else time
+            result = principal * _pct_to_decimal(rate) * t_years
+
+            return _build_result(
+                topic="simple_interest",
+                internal_answer=result,
+                ask="Find interest earned using the simple interest formula.",
+                given=f"principal = {principal}, rate = {rate}%, time = {time} {unit}",
+                method=[
+                    "Use simple interest = principal × rate × time.",
+                    "Convert the rate to decimal form.",
+                    "Make sure time is in the same units as the rate.",
+                    "If the rate is annual and time is in months, convert months to years first.",
                 ],
             )
 
-    return None
+    # --------------------------------------------------
+    # 13) COMPOUND INTEREST
+    # --------------------------------------------------
+    if "compound interest" in lower or "compounded" in lower:
+        m = re.search(
+            r"(-?\d+(?:\.\d+)?)\s+.*?(\d+(?:\.\d+)?)\s*%\s+.*?compounded\s+(annually|semiannually|quarterly|monthly).*?(\d+(?:\.\d+)?)\s+year",
+            lower
+        )
+        if m:
+            principal = float(m.group(1))
+            rate = float(m.group(2))
+            comp = m.group(3)
+            years = float(m.group(4))
+
+            c_map = {
+                "annually": 1,
+                "semiannually": 2,
+                "quarterly": 4,
+                "monthly": 12,
+            }
+            c = c_map[comp]
+            result = principal * ((1 + _pct_to_decimal(rate) / c) ** (c * years))
+
+            return _build_result(
+                topic="compound_interest",
+                internal_answer=result,
+                ask="Find the final balance after compound interest.",
+                given=f"principal = {principal}, rate = {rate}%, compounded {comp}, time = {years} years",
+                method=[
+                    "Use the compound interest form A = P(1 + r/c)^(ct).",
+                    "Convert the rate to decimal form.",
+                    "Match the compounding frequency to the correct value of c.",
+                    "Substitute carefully before evaluating.",
+                ],
+            )
+
+    # --------------------------------------------------
+    # 14) PERCENTILE
+    # --------------------------------------------------
+    if "percentile" in lower:
+        # Simple interpretation pattern:
+        # "80th percentile out of 120"
+        m = re.search(
+            r"(\d+(?:\.\d+)?)(?:st|nd|rd|th)\s+percentile\s+out\s+of\s+(\d+(?:\.\d+)?)",
+            lower
+        )
+        if m:
+            pct = float(m.group(1))
+            total = float(m.group(2))
+            result = _pct_to_decimal(pct) * total
+            return _build_result(
+                topic="percentile",
+                internal_answer=result,
+                ask="Interpret a percentile as the proportion of the group below that score.",
+                given=f"{pct}th percentile out of {total}",
+                method=[
+                    "Convert the percentile to a decimal proportion.",
+                    "Multiply by the total group size to estimate how many are below that position.",
+                    "Check the wording carefully: percentile usually refers to the percentage of values below a score.",
+                ],
+            )
+
+    # --------------------------------------------------
+    # 15) GENERIC HIDDEN PERCENT LANGUAGE
+    #     "out of", "of", "remaining", "sale", etc.
+    # --------------------------------------------------
+    if len(nums) >= 2 and any(k in lower for k in ["out of", "remaining", "sale", "discount", "tax", "tip", "profit", "loss"]):
+        return SolverResult(
+            domain="quant",
+            solved=False,
+            topic="percent",
+            answer_value=None,
+            internal_answer=None,
+            steps=[
+                "This looks like a percent-style word problem.",
+                "What the question is asking: first decide whether the unknown is the part, whole, rate, original value, or changed value.",
+                "Useful checks:",
+                "• 'out of' often signals part/whole",
+                "• 'discount', 'tax', 'tip', 'markup' often signal multiplier use",
+                "• 'profit'/'loss' uses cost price as the base",
+                "• 'from ... to ...' often signals percent change",
+            ],
+        )
+
+    return _fallback_percent()