Create solver_probability.py

solver_probability.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import re
+from math import comb, perm
+from typing import Optional, List
+
+from models import SolverResult
+
+
+def _nums(text: str) -> List[int]:
+    return [int(x) for x in re.findall(r"-?\d+", text)]
+
+
+def solve_probability(text: str) -> Optional[SolverResult]:
+    lower = (text or "").lower()
+
+    prob_words = [
+        "probability", "chance", "likely", "dice", "die", "coin", "cards",
+        "card", "deck", "random", "at random", "marble", "ball", "urn",
+        "without replacement", "with replacement"
+    ]
+    if not any(w in lower for w in prob_words):
+        return None
+
+    nums = _nums(lower)
+
+    # Pattern 1: simple favorable / total
+    m = re.search(
+        r"probability.*?(\d+).*?out of.*?(\d+)",
+        lower,
+    )
+    if m:
+        fav = int(m.group(1))
+        total = int(m.group(2))
+        if total == 0:
+            return None
+        result = fav / total
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="probability",
+            answer_value=f"{result:g}",
+            internal_answer=f"{result:g}",
+            steps=[
+                "Use probability = favorable outcomes ÷ total outcomes.",
+            ],
+        )
+
+    # Pattern 2: one die
+    if ("die" in lower or "dice" in lower) and "even" in lower:
+        result = 3 / 6
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="probability",
+            answer_value=f"{result:g}",
+            internal_answer=f"{result:g}",
+            steps=[
+                "A fair die has 6 equally likely outcomes.",
+                "Even outcomes are 2, 4, and 6, so there are 3 favorable outcomes.",
+                "Probability = 3/6.",
+            ],
+        )
+
+    if ("coin" in lower) and ("head" in lower or "heads" in lower):
+        # one fair coin if not otherwise specified
+        if "twice" not in lower and "two" not in lower:
+            result = 1 / 2
+            return SolverResult(
+                domain="quant",
+                solved=True,
+                topic="probability",
+                answer_value=f"{result:g}",
+                internal_answer=f"{result:g}",
+                steps=[
+                    "A fair coin has 2 equally likely outcomes.",
+                    "Heads is 1 favorable outcome out of 2.",
+                ],
+            )
+
+    # Pattern 3: at least one head in n fair tosses
+    m = re.search(r"(?:coin.*?tossed|toss.*?coin).*?(\d+)\s+times", lower)
+    if m and "at least one head" in lower:
+        n = int(m.group(1))
+        result = 1 - (1 / 2) ** n
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="probability",
+            answer_value=f"{result:g}",
+            internal_answer=f"{result:g}",
+            steps=[
+                "Use the complement: at least one head = 1 − P(no heads).",
+                "For a fair coin, P(no heads in n tosses) = (1/2)^n.",
+            ],
+        )
+
+    # Pattern 4: drawing one item from a set
+    if any(w in lower for w in ["marble", "ball", "urn", "bag"]) and len(nums) >= 2:
+        if any(w in lower for w in ["red", "blue", "green", "white", "black"]):
+            total = sum(nums[:-1]) if "total" not in lower else nums[-1]
+            # conservative: if exactly 2 nums, assume favorable then total
+            if len(nums) == 2:
+                favorable, total = nums[0], nums[1]
+            else:
+                favorable = nums[0]
+                if total == 0:
+                    total = sum(nums)
+            if total == 0:
+                return None
+            result = favorable / total
+            return SolverResult(
+                domain="quant",
+                solved=True,
+                topic="probability",
+                answer_value=f"{result:g}",
+                internal_answer=f"{result:g}",
+                steps=[
+                    "Probability = number of favorable items ÷ total number of items.",
+                ],
+            )
+
+    # Pattern 5: combinations-based probability
+    # Example: choose 2 from 5 red and 3 blue, both red
+    m = re.search(
+        r"(\d+)\s+red.*?(\d+)\s+blue.*?choose\s+(\d+).*?both red",
+        lower,
+    )
+    if m:
+        red = int(m.group(1))
+        blue = int(m.group(2))
+        choose_n = int(m.group(3))
+        total = red + blue
+        if choose_n != 2 or total < 2 or red < 2:
+            return None
+        result = comb(red, 2) / comb(total, 2)
+        return SolverResult(
+            domain="quant",
+            solved=True,
+            topic="probability",
+            answer_value=f"{result:g}",
+            internal_answer=f"{result:g}",
+            steps=[
+                "Count favorable selections.",
+                "Count total possible selections.",
+                "Probability = favorable ÷ total.",
+            ],
+        )
+
+    # Pattern 6: at least / exactly from combinations
+    if "exactly" in lower and "probability" in lower and len(nums) >= 4:
+        # too ambiguous, skip unless explicit structure is added later
+        return None
+
+    return None