Update solver_work_rate.py

solver_work_rate.py

@@ -1,42 +1,797 @@
 from __future__ import annotations
 
+import math
 import re
-from typing import Optional
+from fractions import Fraction
+from typing import Callable, Iterable, Optional
 
 from models import SolverResult
 
 
-def solve_work_rate(text: str) -> Optional[SolverResult]:
+# ============================================================
+# Core helpers
+# ============================================================
 
-    lower = text.lower()
+NUMBER = r"-?\d+(?:\.\d+)?"
+FRACTION = r"\d+\s*/\s*\d+"
+NUMTOKEN = rf"(?:{FRACTION}|{NUMBER})"
 
-    if "together" not in lower and "work together" not in lower:
-        return None
 
-    times = [float(x) for x in re.findall(r"\d+(?:\.\d+)?", lower)]
+def _norm(text: str) -> str:
+    s = (text or "").strip()
+    s = s.replace("’", "'").replace("“", '"').replace("”", '"')
+    s = s.replace("–", "-").replace("—", "-")
+    s = s.replace("per cent", "percent")
+    s = re.sub(r"\s+", " ", s)
+    return s
 
-    if len(times) < 2:
+
+def _to_float(token: str) -> float:
+    token = token.strip()
+    if "/" in token and re.fullmatch(r"\d+\s*/\s*\d+", token):
+        a, b = token.split("/")
+        return float(Fraction(int(a.strip()), int(b.strip())))
+    return float(token)
+
+
+def _safe_div(a: float, b: float) -> Optional[float]:
+    if abs(b) < 1e-12:
         return None
+    return a / b
 
-    t1 = times[0]
-    t2 = times[1]
 
-    rate = (1 / t1) + (1 / t2)
+def _approx_int(x: float, tol: float = 1e-9) -> bool:
+    return abs(x - round(x)) <= tol
 
-    if rate == 0:
+
+def _clean_num(x: Optional[float]) -> Optional[str]:
+    if x is None:
+        return None
+    if not math.isfinite(x):
         return None
+    if _approx_int(x):
+        return str(int(round(x)))
+    return f"{x:.6g}"
+
 
-    total_time = 1 / rate
+def _make_result(
+    topic: str,
+    internal_answer: Optional[float],
+    steps: list[str],
+    method: Optional[str] = None,
+    what_is_asked: Optional[str] = None,
+) -> SolverResult:
+    extra_steps = []
+    if what_is_asked:
+        extra_steps.append(f"What the question is asking: {what_is_asked}")
+    if method:
+        extra_steps.append(f"Method: {method}")
 
+    # Do not reveal the final value in visible fields.
     return SolverResult(
         domain="quant",
-        solved=True,
+        solved=internal_answer is not None,
+        topic=topic,
+        answer_value=None,
+        internal_answer=_clean_num(internal_answer),
+        steps=extra_steps + steps,
+    )
+
+
+def _contains_any(lower: str, phrases: Iterable[str]) -> bool:
+    return any(p in lower for p in phrases)
+
+
+def _extract_all_numbers(text: str) -> list[float]:
+    return [_to_float(m.group(0)) for m in re.finditer(NUMTOKEN, text)]
+
+
+def _extract_time_units(lower: str) -> bool:
+    return bool(re.search(r"\b(hour|hours|hr|hrs|minute|minutes|min|day|days)\b", lower))
+
+
+def _workish(lower: str) -> bool:
+    keywords = [
+        "work", "together", "alone", "finish", "complete", "completed",
+        "job", "task", "paint", "printer", "prints", "machine", "machines",
+        "crew", "worker", "workers", "pipe", "pipes", "tap", "faucet",
+        "fill", "filled", "drain", "drains", "empty", "empties",
+        "leak", "leaks", "produce", "produces", "manufacture", "manufactures",
+        "pages per minute", "sprockets per hour", "rate"
+    ]
+    return _contains_any(lower, keywords)
+
+
+def _distanceish(lower: str) -> bool:
+    keywords = [
+        "distance", "mile", "miles", "km", "kilometer", "kilometers",
+        "speed", "mph", "kph", "miles per hour", "kilometers per hour",
+        "travel", "travels", "moving", "train", "car", "bike", "walk",
+        "upstream", "downstream", "current", "stream"
+    ]
+    return _contains_any(lower, keywords)
+
+
+def _find_times_complete_job(text: str) -> list[float]:
+    """
+    Finds patterns like:
+    - A can do the job in 3 hours
+    - finishes a task in 24 minutes
+    - alone would finish in 60 minutes
+    """
+    pats = [
+        rf"\bin\s+({NUMTOKEN})\s*(?:hour|hours|hr|hrs|minute|minutes|min|day|days)\b",
+        rf"\btakes?\s+({NUMTOKEN})\s*(?:hour|hours|hr|hrs|minute|minutes|min|day|days)\b",
+        rf"\bfinish(?:es)?(?:\s+the\s+\w+)?\s+in\s+({NUMTOKEN})\s*(?:hour|hours|hr|hrs|minute|minutes|min|day|days)\b",
+        rf"\bcomplete(?:s|d)?(?:\s+the\s+\w+)?\s+in\s+({NUMTOKEN})\s*(?:hour|hours|hr|hrs|minute|minutes|min|day|days)\b",
+    ]
+    vals: list[float] = []
+    for pat in pats:
+        for m in re.finditer(pat, text, flags=re.I):
+            vals.append(_to_float(m.group(1)))
+    return vals
+
+
+def _find_percent_more_less(lower: str) -> Optional[tuple[str, float]]:
+    """
+    Returns ("more"/"less", percent_as_decimal)
+    """
+    m = re.search(rf"({NUMTOKEN})\s*%\s*(more|less)", lower)
+    if m:
+        return m.group(2), _to_float(m.group(1)) / 100.0
+    return None
+
+
+def _find_times_faster_slower(lower: str) -> Optional[tuple[str, float]]:
+    """
+    Examples:
+    - B is 2 times as fast as A
+    - Y's rate is 1/10 of X
+    """
+    m = re.search(rf"\b({NUMTOKEN})\s+times?\s+as\s+(fast|slow)\b", lower)
+    if m:
+        return m.group(2), _to_float(m.group(1))
+
+    m2 = re.search(rf"\brate\s+is\s+({NUMTOKEN})\s+of\b", lower)
+    if m2:
+        return "multiplier", _to_float(m2.group(1))
+    return None
+
+
+# ============================================================
+# Work-rate solving blocks
+# ============================================================
+
+def _solve_basic_together(text: str, lower: str) -> Optional[SolverResult]:
+    """
+    Basic:
+    A in t1, B in t2, how long together?
+    Also handles 3+ workers if multiple independent completion times appear.
+    """
+    if not _contains_any(lower, ["together", "work together", "working together"]):
+        return None
+
+    times = _find_times_complete_job(text)
+    if len(times) < 2:
+        # fallback: use first two numeric tokens only when wording is clearly work-like
+        nums = _extract_all_numbers(text)
+        if len(nums) >= 2 and _workish(lower) and _extract_time_units(lower):
+            times = nums[:2]
+
+    if len(times) < 2:
+        return None
+
+    rates = []
+    for t in times:
+        if t <= 0:
+            return None
+        rates.append(1.0 / t)
+
+    total_rate = sum(rates)
+    total_time = _safe_div(1.0, total_rate)
+    if total_time is None:
+        return None
+
+    return _make_result(
+        topic="work_rate",
+        internal_answer=total_time,
+        what_is_asked="how to combine individual completion times into one combined completion time",
+        method="Convert each worker's time into rate = 1/job per time unit, add the rates, then invert.",
+        steps=[
+            "Identify each worker/machine's individual time for one full job.",
+            "Convert each time into a per-unit work rate using rate = 1 ÷ time.",
+            "Add the rates because work done in the same unit of time combines.",
+            "Take the reciprocal of the combined rate to get total time.",
+        ],
+    )
+
+
+def _solve_combined_and_one_alone(text: str, lower: str) -> Optional[SolverResult]:
+    """
+    Together time + one alone time => other alone time.
+    Example:
+    A and B together finish in 24 min. A alone in 60 min. How long for B alone?
+    """
+    if not _contains_any(lower, ["together", "alone"]):
+        return None
+
+    nums = _extract_all_numbers(text)
+    if len(nums) < 2:
+        return None
+
+    # Heuristic: first number = together time, second = one-alone time
+    t_together = nums[0]
+    t_one = nums[1]
+    if t_together <= 0 or t_one <= 0:
+        return None
+
+    rate_other = (1.0 / t_together) - (1.0 / t_one)
+    t_other = _safe_div(1.0, rate_other)
+    if t_other is None or t_other <= 0:
+        return None
+
+    ask_other_alone = _contains_any(
+        lower,
+        ["how long will", "how long would", "how much time", "alone", "by himself", "by herself", "by itself"]
+    )
+    if not ask_other_alone:
+        return None
+
+    return _make_result(
+        topic="work_rate",
+        internal_answer=t_other,
+        what_is_asked="the missing individual completion time when the combined time and one person's time are known",
+        method="Use combined rate minus known individual rate to isolate the unknown rate, then invert.",
+        steps=[
+            "Write the combined rate as 1 ÷ together-time.",
+            "Write the known person's rate as 1 ÷ known-alone-time.",
+            "Subtract to get the unknown person's rate.",
+            "Invert that unknown rate to get the missing alone time.",
+        ],
+    )
+
+
+def _solve_fraction_done_by_x_then_y(text: str, lower: str) -> Optional[SolverResult]:
+    """
+    Example:
+    X takes 12 hours. He finishes 2/3 of the work.
+    Rest is finished by Y whose rate is 1/10 of X.
+    How much time does Y take for his portion?
+    """
+    if "rest of the work" not in lower and "remaining" not in lower and "finishes" not in lower:
+        return None
+
+    base_time_match = re.search(
+        rf"\btakes?\s+({NUMTOKEN})\s*(hour|hours|hr|hrs|minute|minutes|min|day|days)\b",
+        lower
+    )
+    frac_done_match = re.search(rf"\bfinishes?\s+({NUMTOKEN})\s+of\s+the\s+work\b", lower)
+    rate_ratio_match = re.search(rf"\brate\s+is\s+({NUMTOKEN})\s+of\b", lower)
+
+    if not (base_time_match and frac_done_match and rate_ratio_match):
+        return None
+
+    base_time = _to_float(base_time_match.group(1))
+    frac_done = _to_float(frac_done_match.group(1))
+    ratio = _to_float(rate_ratio_match.group(1))
+
+    if base_time <= 0 or ratio <= 0 or frac_done <= 0 or frac_done >= 1:
+        return None
+
+    remaining = 1.0 - frac_done
+    x_rate = 1.0 / base_time
+    y_rate = ratio * x_rate
+    y_time = _safe_div(remaining, y_rate)
+    if y_time is None or y_time <= 0:
+        return None
+
+    return _make_result(
+        topic="work_rate",
+        internal_answer=y_time,
+        what_is_asked="the time needed for a second worker to complete only the remaining fraction of the job",
+        method="Convert the first worker's time to rate, scale the second worker's rate from the ratio, then divide remaining work by that rate.",
+        steps=[
+            "Convert the known worker's full-job time into a unit rate.",
+            "Translate the completed fraction into remaining work: remaining = 1 - completed fraction.",
+            "Use the stated rate ratio to get the second worker's rate.",
+            "Use time = remaining work ÷ rate.",
+        ],
+    )
+
+
+def _solve_work_after_some_time(text: str, lower: str) -> Optional[SolverResult]:
+    """
+    General remaining-work setup:
+    A can do in a hours, B in b hours. They work together for x hours.
+    How much remains / what fraction remains / how much completed?
+    """
+    if not _contains_any(lower, ["remain", "remains", "remaining", "left", "completed", "after"]):
+        return None
+
+    nums = _extract_all_numbers(text)
+    if len(nums) < 3:
+        return None
+
+    # common GMAT-style heuristic: first two are full-job times, third is elapsed time
+    a, b, x = nums[0], nums[1], nums[2]
+    if a <= 0 or b <= 0 or x < 0:
+        return None
+
+    combined = (1.0 / a) + (1.0 / b)
+    completed = combined * x
+    remaining = 1.0 - completed
+
+    if "remain" in lower or "left" in lower or "remaining" in lower:
+        internal = remaining
+        asked = "the fraction of work still left after some amount of joint work"
+    else:
+        internal = completed
+        asked = "the fraction of work completed after some amount of joint work"
+
+    return _make_result(
+        topic="work_rate",
+        internal_answer=internal,
+        what_is_asked=asked,
+        method="Find the combined rate, multiply by elapsed time to get completed work, then subtract from 1 if the question asks for what remains.",
+        steps=[
+            "Convert each worker's full-job time into a rate.",
+            "Add the rates if they are working simultaneously.",
+            "Multiply the combined rate by the elapsed time to get the completed fraction.",
+            "If the question asks what remains, subtract that completed fraction from 1.",
+        ],
+    )
+
+
+def _solve_join_leave_case(text: str, lower: str) -> Optional[SolverResult]:
+    """
+    Handles:
+    - A starts alone, B joins later
+    - A and B start together, one leaves
+    Requires 3 times/numbers in common patterns.
+    """
+    join_words = ["joins", "join", "joined", "after", "left", "leaves", "leave"]
+    if not _contains_any(lower, join_words):
+        return None
+
+    nums = _extract_all_numbers(text)
+    if len(nums) < 3:
+        return None
+
+    a, b, x = nums[0], nums[1], nums[2]
+    if a <= 0 or b <= 0 or x < 0:
+        return None
+
+    a_rate = 1.0 / a
+    b_rate = 1.0 / b
+
+    if _contains_any(lower, ["joins", "join", "joined"]):
+        completed_before_join = a_rate * x
+        remaining = 1.0 - completed_before_join
+        together_rate = a_rate + b_rate
+        rest_time = _safe_div(remaining, together_rate)
+        total_time = None if rest_time is None else x + rest_time
+
+        if total_time is None or total_time <= 0:
+            return None
+
+        return _make_result(
+            topic="work_rate",
+            internal_answer=total_time,
+            what_is_asked="the total completion time when one worker starts first and another joins later",
+            method="Split the job into stages: first-stage work by one worker, then remaining work by the combined rate.",
+            steps=[
+                "Convert each person's full-job time into a rate.",
+                "Compute how much work the first worker finishes before the second joins.",
+                "Subtract from 1 to get the remaining work.",
+                "Use the combined rate for the remaining stage, then add the elapsed starting time.",
+            ],
+        )
+
+    if _contains_any(lower, ["left", "leaves", "leave"]):
+        completed_before_leave = (a_rate + b_rate) * x
+        remaining = 1.0 - completed_before_leave
+        # heuristic: after leaving, first worker continues
+        rest_time = _safe_div(remaining, a_rate)
+        total_time = None if rest_time is None else x + rest_time
+
+        if total_time is None or total_time <= 0:
+            return None
+
+        return _make_result(
+            topic="work_rate",
+            internal_answer=total_time,
+            what_is_asked="the total completion time when workers begin together and one stops after a known amount of time",
+            method="Split the timeline into stages: together first, then remaining work by the continuing worker.",
+            steps=[
+                "Convert each worker's time into a unit work rate.",
+                "Find the completed fraction during the stage when both are active.",
+                "Subtract from 1 to get the remaining fraction.",
+                "Finish the remainder using the continuing worker's rate and add stage times.",
+            ],
+        )
+
+    return None
+
+
+def _solve_fill_drain(text: str, lower: str) -> Optional[SolverResult]:
+    """
+    Pipes/tanks:
+    fill in a hours, drain/empty in b hours => net rate = 1/a - 1/b
+    """
+    if not _contains_any(lower, ["pipe", "pipes", "fill", "filled", "drain", "drains", "empty", "empties", "leak", "leaks", "tank", "cistern"]):
+        return None
+
+    nums = _extract_all_numbers(text)
+    if len(nums) < 2:
+        return None
+
+    a, b = nums[0], nums[1]
+    if a <= 0 or b <= 0:
+        return None
+
+    fill_rate = 1.0 / a
+    drain_rate = 1.0 / b
+    net = fill_rate - drain_rate
+
+    if net <= 0:
+        return None
+
+    t = _safe_div(1.0, net)
+    if t is None:
+        return None
+
+    return _make_result(
+        topic="work_rate",
+        internal_answer=t,
+        what_is_asked="the net completion time when one process adds work and another removes it",
+        method="Treat filling as positive rate and draining/leaking as negative rate, then invert the net rate.",
+        steps=[
+            "Convert the filling time into a positive rate.",
+            "Convert the draining/leaking time into a negative rate.",
+            "Subtract the drain rate from the fill rate to get the net rate.",
+            "Take the reciprocal of the net rate to get total time.",
+        ],
+    )
+
+
+def _solve_page_rate_difference(text: str, lower: str) -> Optional[SolverResult]:
+    """
+    Example:
+    Together finish in 24 min. A alone in 60 min.
+    B prints 5 pages/min more than A.
+    How many pages in task?
+    """
+    if "pages" not in lower and "pages a minute" not in lower and "prints" not in lower:
+        return None
+
+    nums = _extract_all_numbers(text)
+    if len(nums) < 3:
+        return None
+
+    together_time, a_time, diff_pages = nums[0], nums[1], nums[2]
+    if together_time <= 0 or a_time <= 0 or diff_pages <= 0:
+        return None
+
+    # difference in job/minute between B and A
+    b_job_rate = (1.0 / together_time) - (1.0 / a_time)
+    a_job_rate = 1.0 / a_time
+    job_rate_difference = abs(b_job_rate - a_job_rate)
+
+    if job_rate_difference <= 0:
+        return None
+
+    pages_total = _safe_div(diff_pages, job_rate_difference)
+    if pages_total is None or pages_total <= 0:
+        return None
+
+    return _make_result(
+        topic="work_rate",
+        internal_answer=pages_total,
+        what_is_asked="the total size of the job when job-rate differences correspond to a page-per-minute difference",
+        method="Translate both workers into job/minute, compare those job-rates, then scale that difference up to the stated page difference.",
+        steps=[
+            "Write the combined job rate using the together time.",
+            "Write the known worker's job rate using the alone time.",
+            "Subtract to get the other worker's job rate.",
+            "Find the difference in their job-rates per minute.",
+            "Use the fact that this difference corresponds to the stated pages-per-minute gap to scale up to the full job size.",
+        ],
+    )
+
+
+def _solve_percent_more_output_fixed_total(text: str, lower: str) -> Optional[SolverResult]:
+    """
+    Example:
+    A takes 10 hours longer than B to produce 660 sprockets.
+    B produces 10% more per hour than A.
+    Find A's rate.
+    """
+    if not _contains_any(lower, ["more per hour", "less per hour", "produces", "produce", "manufacture", "sprockets", "pages"]):
+        return None
+
+    nums = _extract_all_numbers(text)
+    pm = _find_percent_more_less(lower)
+
+    if len(nums) < 3 or pm is None:
+        return None
+
+    total_units = nums[0]
+    time_difference = nums[1]
+    kind, pct = pm
+
+    if total_units <= 0 or time_difference <= 0 or pct <= 0:
+        return None
+
+    # Let A = r units/time. B = r(1+p) if "more", else r(1-p)
+    multiplier = (1.0 + pct) if kind == "more" else (1.0 - pct)
+    if multiplier <= 0:
+        return None
+
+    # total/r - total/(multiplier*r) = time_difference
+    # total * (1 - 1/multiplier) / r = time_difference
+    numerator = total_units * (1.0 - 1.0 / multiplier)
+    r = _safe_div(numerator, time_difference)
+    if r is None or r <= 0:
+        return None
+
+    return _make_result(
         topic="work_rate",
-        answer_value=f"{total_time:g}",
-        internal_answer=f"{total_time:g}",
-        steps=[
-            "Convert each time to a work rate.",
-            "Add the rates together.",
-            "Take the reciprocal to get the total time."
-        ]
-    )
+        internal_answer=r,
+        what_is_asked="the base production rate when total output, time difference, and relative efficiency are given",
+        method="Let the slower rate be r, express the faster rate using the percent relationship, write time = total ÷ rate for each, and subtract the times.",
+        steps=[
+            "Assign a variable to the unknown base production rate.",
+            "Translate the percent-more/less statement into the other machine's rate.",
+            "Write each completion time as total output ÷ rate.",
+            "Use the stated time difference to form one equation and solve for the base rate.",
+        ],
+    )
+
+
+def _solve_direct_rate_from_units_and_time(text: str, lower: str) -> Optional[SolverResult]:
+    """
+    Direct unit-rate:
+    660 sprockets in 12 hours -> 55 per hour
+    distance/rate/time analogue included.
+    """
+    if not _contains_any(lower, ["per hour", "per minute", "per day", "rate", "speed", "mph", "kph"]):
+        return None
+
+    nums = _extract_all_numbers(text)
+    if len(nums) < 2:
+        return None
+
+    a, b = nums[0], nums[1]
+    if a <= 0 or b <= 0:
+        return None
+
+    # Heuristic: if asks "per hour" or "speed", compute units/time
+    if _contains_any(lower, ["per hour", "per minute", "per day", "speed", "mph", "kph"]):
+        rate = _safe_div(a, b)
+        if rate is None or rate <= 0:
+            return None
+
+        topic = "distance_rate" if _distanceish(lower) else "work_rate"
+        asked = (
+            "the unit rate or speed from a total amount and a time"
+            if topic == "work_rate"
+            else "the speed from distance and time"
+        )
+        method = (
+            "Use rate = total work ÷ time."
+            if topic == "work_rate"
+            else "Use speed = distance ÷ time."
+        )
+
+        return _make_result(
+            topic=topic,
+            internal_answer=rate,
+            what_is_asked=asked,
+            method=method,
+            steps=[
+                "Identify the total amount completed or traveled.",
+                "Identify the time taken.",
+                "Use rate = amount ÷ time.",
+            ],
+        )
+
+    return None
+
+
+# ============================================================
+# Distance/rate sub-blocks
+# ============================================================
+
+def _solve_distance_speed_time(text: str, lower: str) -> Optional[SolverResult]:
+    """
+    Basic distance = rate * time family.
+    Supports solving for one missing quantity in simple 2-number problems.
+    """
+    if not _distanceish(lower):
+        return None
+
+    nums = _extract_all_numbers(text)
+    if len(nums) < 2:
+        return None
+
+    a, b = nums[0], nums[1]
+    if a <= 0 or b <= 0:
+        return None
+
+    if "how far" in lower or "distance" in lower:
+        d = a * b
+        return _make_result(
+            topic="distance_rate",
+            internal_answer=d,
+            what_is_asked="the distance traveled from speed and time",
+            method="Use distance = rate × time.",
+            steps=[
+                "Identify the rate/speed.",
+                "Identify the travel time.",
+                "Multiply rate by time to get distance.",
+            ],
+        )
+
+    if "how long" in lower or "how much time" in lower:
+        t = _safe_div(a, b)
+        if t is None or t <= 0:
+            return None
+        return _make_result(
+            topic="distance_rate",
+            internal_answer=t,
+            what_is_asked="the travel time from distance and speed",
+            method="Use time = distance ÷ rate.",
+            steps=[
+                "Identify the total distance.",
+                "Identify the speed.",
+                "Divide distance by speed to get time.",
+            ],
+        )
+
+    if "what speed" in lower or "what is the speed" in lower or "mph" in lower or "kph" in lower:
+        s = _safe_div(a, b)
+        if s is None or s <= 0:
+            return None
+        return _make_result(
+            topic="distance_rate",
+            internal_answer=s,
+            what_is_asked="the speed from distance and time",
+            method="Use speed = distance ÷ time.",
+            steps=[
+                "Identify the distance.",
+                "Identify the time.",
+                "Divide distance by time to get speed.",
+            ],
+        )
+
+    return None
+
+
+def _solve_relative_speed(text: str, lower: str) -> Optional[SolverResult]:
+    """
+    Relative speed:
+    - towards each other => add speeds
+    - same direction / catches up => subtract speeds
+    """
+    if not _distanceish(lower):
+        return None
+
+    if not _contains_any(lower, ["towards each other", "opposite directions", "same direction", "catch up", "catches up"]):
+        return None
+
+    nums = _extract_all_numbers(text)
+    if len(nums) < 2:
+        return None
+
+    v1, v2 = nums[0], nums[1]
+    if v1 <= 0 or v2 <= 0:
+        return None
+
+    if _contains_any(lower, ["towards each other", "opposite directions"]):
+        rel = v1 + v2
+        ask = "the relative speed when two objects move toward each other or in opposite directions"
+        meth = "Add the speeds because separation changes by both rates together."
+    else:
+        rel = abs(v1 - v2)
+        ask = "the relative speed when two objects move in the same direction"
+        meth = "Subtract the speeds because only the speed difference closes the gap."
+
+    return _make_result(
+        topic="distance_rate",
+        internal_answer=rel,
+        what_is_asked=ask,
+        method=meth,
+        steps=[
+            "Decide whether the motion uses addition or subtraction of speeds.",
+            "Use addition for opposite directions/toward each other.",
+            "Use subtraction for same-direction chase situations.",
+        ],
+    )
+
+
+# ============================================================
+# Question-explainer fallback
+# ============================================================
+
+def _explain_work_rate_without_solving(lower: str) -> Optional[SolverResult]:
+    explain_triggers = [
+        "what is this asking",
+        "what does this mean",
+        "how do i set this up",
+        "how should i think about this",
+        "explain the question",
+        "decode the question",
+    ]
+    if not _contains_any(lower, explain_triggers):
+        return None
+
+    if _workish(lower):
+        return _make_result(
+            topic="work_rate",
+            internal_answer=None,
+            what_is_asked="how to translate a work/rate word problem into rate equations",
+            method="Use a unit-job model: job = 1, rate = fraction of job per unit time, time = work ÷ rate.",
+            steps=[
+                "Treat the whole task as 1 complete job.",
+                "Convert each person's completion time into a rate using 1 ÷ time.",
+                "Add rates when people work together at the same time.",
+                "Subtract rates when one process undoes another, like draining or leaking.",
+                "For multi-stage problems, track completed work and remaining work separately.",
+                "For percentage or ratio statements, convert the wording into algebra before solving.",
+            ],
+        )
+
+    if _distanceish(lower):
+        return _make_result(
+            topic="distance_rate",
+            internal_answer=None,
+            what_is_asked="how to translate a distance/rate question into equations",
+            method="Use the distance-rate-time relationship and choose the form that matches the missing quantity.",
+            steps=[
+                "Identify which quantity is missing: distance, speed, or time.",
+                "Use distance = speed × time.",
+                "Rearrange to speed = distance ÷ time or time = distance ÷ speed when needed.",
+                "For relative motion, add speeds when moving toward each other and subtract when moving in the same direction.",
+            ],
+        )
+
+    return None
+
+
+# ============================================================
+# Main entry point
+# ============================================================
+
+def solve_work_rate(text: str) -> Optional[SolverResult]:
+    raw = _norm(text)
+    lower = raw.lower()
+
+    # Broad gateway: this solver now intentionally covers work/rate and
+    # a useful distance/rate subset because the user wanted wider rate coverage.
+    if not (_workish(lower) or _distanceish(lower) or "rate" in lower):
+        return None
+
+    solvers: list[Callable[[str, str], Optional[SolverResult]]] = [
+        _solve_fraction_done_by_x_then_y,
+        _solve_page_rate_difference,
+        _solve_percent_more_output_fixed_total,
+        _solve_join_leave_case,
+        _solve_fill_drain,
+        _solve_work_after_some_time,
+        _solve_combined_and_one_alone,
+        _solve_basic_together,
+        _solve_relative_speed,
+        _solve_distance_speed_time,
+        _solve_direct_rate_from_units_and_time,
+        _explain_work_rate_without_solving,
+    ]
+
+    for solver in solvers:
+        try:
+            result = solver(raw, lower)
+            if result is not None:
+                return result
+        except Exception:
+            continue
+
+    return None