Upload solver_a.py with huggingface_hub

solver_a.py

@@ -0,0 +1,591 @@
+"""Primary solver. Stdlib `datetime` and `zoneinfo`, plus fedcal for the holiday table.
+
+This is the implementation the released scorer calls to recompute gold answers. It also
+produces the working section that the training completions show, because the walk that
+computes the answer is the same walk the working describes; deriving them separately
+would let a completion narrate a computation that did not happen.
+
+Solver B (solver_b.py) answers the same questions from scratch with different
+algorithms and different primitives, and verify_rows.py drops any row where the two
+disagree. Everything here is therefore written for clarity rather than for cleverness:
+if a reviewer cannot follow it, it is not doing its job.
+
+THE ONE TRAP THAT MATTERS, and the reason the dual-solver gate exists at all.
+`datetime.__sub__` on two aware datetimes SHORT-CIRCUITS when both carry the same
+tzinfo object: it subtracts the wall-clock fields and never calls utcoffset(). Across a
+DST transition that is simply wrong. Verified locally on 2026-07-28:
+
+    a = datetime(2026, 10, 31, 22, 0, tzinfo=ZoneInfo("America/New_York"))
+    b = datetime(2026, 11,  1,  6, 0, tzinfo=ZoneInfo("America/New_York"))
+    b - a                                              -> 8:00:00   WRONG
+    b.astimezone(utc) - a.astimezone(utc)              -> 9:00:00   right
+
+Nine hours is correct: 2026-11-01 is the first Sunday in November, the hour from 01:00
+to 02:00 local runs twice, and the offset moves from -04:00 to -05:00. F3 always
+converts both endpoints to UTC first, and `_selftest` keeps that as a regression test.
+
+PARAMETER SCHEMAS. Every family's gold answer is a pure function of these fields, which
+is what lets the released scorer recompute all of them from the row file alone.
+
+  F1  {"family":"F1", "anchor":"YYYY-MM-DD", "n":1..15, "direction":"after"|"before"}
+  F2  {"family":"F2", "anchor":"YYYY-MM-DD", "n":1..60, "direction":"after"|"before",
+       "roll":"forward"|"backward"}
+  F3  {"family":"F3", "start":{"dt":"YYYY-MM-DDTHH:MM","zone":<IANA>},
+       "end":{"dt":"YYYY-MM-DDTHH:MM","zone":<IANA>}}
+  F4  {"family":"F4", "schedule":{...}, "after":"YYYY-MM-DD", "adjust":"prior"|"next"}
+  F5  {"family":"F5", "kind":..., "date":"YYYY-MM-DD", ...}
+"""
+from __future__ import annotations
+
+import sys
+from datetime import date, datetime, timedelta, timezone
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import fedcal  # noqa: E402
+
+DAY_ABBR = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
+DAY_FULL = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")
+MONTH_FULL = ("January", "February", "March", "April", "May", "June", "July",
+              "August", "September", "October", "November", "December")
+
+ANSWER_TYPES = {"F1": "date", "F2": "date", "F3": "duration", "F4": "date", "F5": "isoweek"}
+
+# Caps declared in the task contract and enforced here, not only in the generator. A
+# generator bug that emitted n=200 would otherwise produce a valid-looking gold answer
+# for a scenario the corpus never promised to cover.
+N_CAPS = {"F1": (1, 15), "F2": (1, 60)}
+
+
+class SolverError(ValueError):
+    """Raised on a scenario the contract does not cover. Never returns a guess."""
+
+
+def abbr(d: date) -> str:
+    return DAY_ABBR[d.weekday()]
+
+
+def full_weekday(d: date) -> str:
+    return DAY_FULL[d.weekday()]
+
+
+def _d(s: str) -> date:
+    return date.fromisoformat(s)
+
+
+# ---------------------------------------------------------------- business days
+
+def _step_business(d: date, forward: bool) -> date:
+    step = timedelta(days=1 if forward else -1)
+    cur = d + step
+    while not fedcal.is_business_day(cur):
+        cur += step
+    return cur
+
+
+def business_days_offset(anchor: date, n: int, forward: bool) -> tuple[date, list[str]]:
+    """The nth business day strictly after (or before) `anchor`, with a per-day trace.
+
+    Day-by-day on purpose. Solver B does the same thing in closed form with a holiday
+    correction loop, so an off-by-one in either is visible as a disagreement.
+    """
+    if n < 1:
+        raise SolverError(f"n must be at least 1, got {n}")
+    lines: list[str] = []
+    cur = anchor
+    counted = 0
+    step = timedelta(days=1 if forward else -1)
+    while counted < n:
+        cur += step
+        name = fedcal.holiday_name(cur)
+        if cur.weekday() >= 5:
+            lines.append(f"{abbr(cur)} {cur.isoformat()}: weekend, skip")
+        elif name:
+            lines.append(f"{abbr(cur)} {cur.isoformat()}: holiday ({name}), skip")
+        else:
+            counted += 1
+            lines.append(f"{abbr(cur)} {cur.isoformat()}: business day {counted}")
+    return cur, lines
+
+
+def roll(d: date, forward: bool) -> tuple[date, list[str]]:
+    """Move to the nearest business day on or after (or on or before) `d`."""
+    lines: list[str] = []
+    cur = d
+    word = "roll forward" if forward else "roll backward"
+    while not fedcal.is_business_day(cur):
+        name = fedcal.holiday_name(cur)
+        why = f"holiday ({name})" if name else "weekend"
+        lines.append(f"{abbr(cur)} {cur.isoformat()}: {why}, {word}")
+        cur += timedelta(days=1 if forward else -1)
+    lines.append(f"{abbr(cur)} {cur.isoformat()}: business day, stop")
+    return cur, lines
+
+
+# ---------------------------------------------------------------- F1
+
+def solve_f1(p: dict) -> tuple[str, list[str]]:
+    lo, hi = N_CAPS["F1"]
+    if not lo <= p["n"] <= hi:
+        raise SolverError(f"F1 n={p['n']} outside the declared cap {lo}..{hi}")
+    anchor = _d(p["anchor"])
+    forward = p["direction"] == "after"
+    end, walk = business_days_offset(anchor, p["n"], forward)
+    head = (f"Anchor {abbr(anchor)} {anchor.isoformat()}, count {p['n']} business "
+            f"{'day' if p['n'] == 1 else 'days'} "
+            f"{'forward' if forward else 'backward'}.")
+    return end.isoformat(), [head] + walk
+
+
+# ---------------------------------------------------------------- F2
+
+def _calendar_add_lines(anchor: date, n: int, forward: bool) -> tuple[date, list[str]]:
+    """Add or subtract n calendar days, narrated one month boundary at a time.
+
+    Month-sized chunks rather than n single steps, because n runs to 60 and a
+    sixty-arrow chain is a token bill, not an explanation. n <= 60 crosses at most two
+    month boundaries, so this is always three lines or fewer.
+
+    Each chunk is "however many days reach the first of the next month" going forward,
+    or "however many reach the first of this month, then whole months" going back. The
+    first draft used "days remaining until the end of this month", which is ZERO when
+    the anchor is already the last day of a month, and looped forever on the very first
+    case the selftest tried (2026-06-30 plus 45 days). Chunk sizes are asserted
+    positive below so that class of bug cannot come back silently.
+    """
+    lines: list[str] = []
+    cur = anchor
+    rem = n
+    while rem > 0:
+        if forward:
+            avail = fedcal._days_in_month(cur.year, cur.month) - cur.day + 1
+        elif cur.day > 1:
+            avail = cur.day - 1
+        else:
+            prev_end = cur - timedelta(days=1)
+            avail = fedcal._days_in_month(prev_end.year, prev_end.month)
+        assert avail > 0, f"non-advancing chunk at {cur} (forward={forward})"
+        k = min(rem, avail)
+        nxt = cur + timedelta(days=k if forward else -k)
+        word = "day" if k == 1 else "days"
+        if k == rem:
+            lines.append(f"Then {k} more {word}{'' if forward else ' back'}: "
+                         f"landing {nxt.isoformat()}.")
+        else:
+            lines.append(f"{'To' if forward else 'Back to'} {nxt.isoformat()}, the start "
+                         f"of {MONTH_FULL[nxt.month - 1]}: {k} {word}, {rem - k} remain.")
+        rem -= k
+        cur = nxt
+    return cur, lines
+
+
+def solve_f2(p: dict) -> tuple[str, list[str]]:
+    lo, hi = N_CAPS["F2"]
+    if not lo <= p["n"] <= hi:
+        raise SolverError(f"F2 n={p['n']} outside the declared cap {lo}..{hi}")
+    anchor = _d(p["anchor"])
+    forward = p["direction"] == "after"
+    landing, add_lines = _calendar_add_lines(anchor, p["n"], forward)
+    head = (f"Anchor {abbr(anchor)} {anchor.isoformat()}, "
+            f"{'add' if forward else 'subtract'} {p['n']} calendar "
+            f"{'day' if p['n'] == 1 else 'days'}.")
+    lines = [head] + add_lines
+    if fedcal.is_business_day(landing):
+        lines.append(f"Landing {abbr(landing)} {landing.isoformat()}: business day, "
+                     f"no adjustment needed.")
+        return landing.isoformat(), lines
+    final, roll_lines = roll(landing, p["roll"] == "forward")
+    lines.append(f"Landing {abbr(landing)} {landing.isoformat()}.")
+    lines.extend(roll_lines)
+    return final.isoformat(), lines
+
+
+# ---------------------------------------------------------------- F3
+
+def _offset_str(dt: datetime) -> str:
+    off = dt.utcoffset()
+    if off is None:
+        raise SolverError("naive datetime has no offset")
+    total = int(off.total_seconds()) // 60
+    sign = "+" if total >= 0 else "-"
+    total = abs(total)
+    return f"{sign}{total // 60:02d}:{total % 60:02d}"
+
+
+def _aware(spec: dict) -> datetime:
+    naive = datetime.fromisoformat(spec["dt"])
+    if naive.second or naive.microsecond:
+        raise SolverError("F3 endpoints must land on a whole minute")
+    return naive.replace(tzinfo=ZoneInfo(spec["zone"]))
+
+
+def endpoint_is_unambiguous(spec: dict) -> bool:
+    """True when the local time exists exactly once in its zone.
+
+    fold=0 and fold=1 must give the same offset. That is false during a fall-back
+    repeat (the hour happens twice) and, for a spring-forward gap, the roundtrip
+    through UTC does not return the original wall clock. Both are rejected as
+    ENDPOINTS. Intervals are still free to SPAN a transition, which is the whole
+    point of the family.
+    """
+    naive = datetime.fromisoformat(spec["dt"])
+    zone = ZoneInfo(spec["zone"])
+    a = naive.replace(tzinfo=zone, fold=0)
+    b = naive.replace(tzinfo=zone, fold=1)
+    if a.utcoffset() != b.utcoffset():
+        return False
+    back = a.astimezone(timezone.utc).astimezone(zone)
+    return back.replace(tzinfo=None) == naive
+
+
+def format_hmm(total_minutes: int) -> str:
+    """H:MM. Hours may exceed 24, minutes always two digits, hours never zero-padded."""
+    if total_minutes < 0:
+        raise SolverError("negative elapsed time is not part of the contract")
+    return f"{total_minutes // 60}:{total_minutes % 60:02d}"
+
+
+def solve_f3(p: dict) -> tuple[str, list[str]]:
+    for side in ("start", "end"):
+        if not endpoint_is_unambiguous(p[side]):
+            raise SolverError(f"F3 {side} endpoint {p[side]} is ambiguous or does not exist")
+    a, b = _aware(p["start"]), _aware(p["end"])
+    au, bu = a.astimezone(timezone.utc), b.astimezone(timezone.utc)
+    delta = bu - au
+    if delta.total_seconds() < 0:
+        raise SolverError("end precedes start")
+    minutes = int(delta.total_seconds()) // 60
+    fmt = "%Y-%m-%dT%H:%M"
+    lines = [
+        f"Start {a.strftime(fmt)} {p['start']['zone']}, UTC offset {_offset_str(a)}, "
+        f"so {au.strftime(fmt)} UTC.",
+        f"End {b.strftime(fmt)} {p['end']['zone']}, UTC offset {_offset_str(b)}, "
+        f"so {bu.strftime(fmt)} UTC.",
+        f"Elapsed {bu.strftime(fmt)} UTC minus {au.strftime(fmt)} UTC = {minutes} minutes.",
+        f"{minutes} minutes = {minutes // 60} "
+        f"{'hour' if minutes // 60 == 1 else 'hours'} {minutes % 60} "
+        f"{'minute' if minutes % 60 == 1 else 'minutes'}.",
+    ]
+    return format_hmm(minutes), lines
+
+
+# ---------------------------------------------------------------- F4
+
+def _month_iter(start: date, months: int):
+    y, m = start.year, start.month
+    for _ in range(months):
+        yield y, m
+        m += 1
+        if m == 13:
+            y, m = y + 1, 1
+
+
+def nominal_dates(schedule: dict, y: int, m: int) -> list[date]:
+    """The scheduled days in one month, before any business-day adjustment."""
+    k = schedule["kind"]
+    dim = fedcal._days_in_month(y, m)
+    if k == "day_of_month":
+        return [date(y, m, schedule["day"])]
+    if k == "month_end":
+        return [date(y, m, dim)]
+    if k == "semimonthly":
+        return [date(y, m, schedule["day"]), date(y, m, dim)]
+    if k == "quarter_end":
+        return [date(y, m, dim)] if m in (3, 6, 9, 12) else []
+    if k == "nth_weekday":
+        return [fedcal._nth_weekday(y, m, schedule["weekday"], schedule["n"])]
+    raise SolverError(f"unknown F4 schedule kind {k!r}")
+
+
+def adjust(d: date, mode: str) -> date:
+    """Unchanged on a business day, otherwise the nearest business day in `mode`."""
+    if fedcal.is_business_day(d):
+        return d
+    step = timedelta(days=-1 if mode == "prior" else 1)
+    cur = d + step
+    while not fedcal.is_business_day(cur):
+        cur += step
+    return cur
+
+
+def solve_f4(p: dict) -> tuple[str, list[str]]:
+    after = _d(p["after"])
+    mode = p["adjust"]
+    if mode not in ("prior", "next"):
+        raise SolverError(f"unknown adjust mode {mode!r}")
+    # Start a month early: an occurrence nominally in the previous month can be pushed
+    # forward past `after`, and one nominally after `after` can be pulled back before it.
+    start = date(after.year, after.month, 1) - timedelta(days=1)
+    start = date(start.year, start.month, 1)
+
+    pairs: list[tuple[date, date]] = []
+    for y, m in _month_iter(start, 18):
+        for nom in nominal_dates(p["schedule"], y, m):
+            pairs.append((nom, adjust(nom, mode)))
+    pairs.sort()
+    hits = sorted({occ for _, occ in pairs if occ > after})
+    if not hits:
+        raise SolverError("no occurrence found in the 18 month search window")
+    answer = hits[0]
+
+    lines: list[str] = []
+    shown = 0
+    for nom, occ in pairs:
+        # Narrate from a little before the answer through it, not the whole window.
+        if occ < after - timedelta(days=40):
+            continue
+        word = "moved back to" if mode == "prior" else "moved forward to"
+        if occ == nom:
+            lines.append(f"Nominal {abbr(nom)} {nom.isoformat()}: business day, "
+                         f"occurrence {occ.isoformat()}.")
+        else:
+            why = fedcal.holiday_name(nom)
+            why = f"holiday ({why})" if why else "weekend"
+            lines.append(f"Nominal {abbr(nom)} {nom.isoformat()}: {why}, {word} "
+                         f"{abbr(occ)} {occ.isoformat()}, occurrence {occ.isoformat()}.")
+        shown += 1
+        if occ >= answer or shown >= 6:
+            break
+    lines.append(f"Earliest occurrence strictly after {after.isoformat()} "
+                 f"is {answer.isoformat()}.")
+    return answer.isoformat(), lines
+
+
+# ---------------------------------------------------------------- F5
+
+def _iso_label(d: date) -> str:
+    iso = d.isocalendar()
+    return f"{iso[0]}-W{iso[1]:02d}"
+
+
+def solve_f5(p: dict) -> tuple[str, list[str]]:
+    base = _d(p["date"])
+    kind = p["kind"]
+    lines: list[str] = []
+    if kind == "of_date":
+        target = base
+        lines.append(f"Target {target.isoformat()} {abbr(target)}.")
+    elif kind == "of_offset_days":
+        target = base + timedelta(days=p["offset_days"])
+        sign = "plus" if p["offset_days"] >= 0 else "minus"
+        lines.append(f"{base.isoformat()} {sign} {abs(p['offset_days'])} calendar days "
+                     f"= {target.isoformat()} {abbr(target)}.")
+    elif kind == "of_offset_weeks":
+        target = base + timedelta(weeks=p["offset_weeks"])
+        sign = "plus" if p["offset_weeks"] >= 0 else "minus"
+        lines.append(f"{base.isoformat()} {sign} {abs(p['offset_weeks'])} weeks "
+                     f"= {abs(p['offset_weeks']) * 7} calendar days = "
+                     f"{target.isoformat()} {abbr(target)}.")
+    elif kind == "of_nth_weekday":
+        target = fedcal._nth_weekday(base.year, base.month, p["weekday"], p["n"])
+        lines.append(f"The {['first', 'second', 'third', 'fourth', 'fifth'][p['n'] - 1]} "
+                     f"{DAY_FULL[p['weekday']]} of {MONTH_FULL[base.month - 1]} "
+                     f"{base.year} is {target.isoformat()}.")
+    else:
+        raise SolverError(f"unknown F5 kind {kind!r}")
+
+    monday = target - timedelta(days=target.weekday())
+    sunday = monday + timedelta(days=6)
+    thursday = monday + timedelta(days=3)
+    iso_year = thursday.year
+    jan_first = date(iso_year, 1, 1)
+    first_thu = jan_first + timedelta(days=(3 - jan_first.weekday()) % 7)
+    week1_monday = first_thu - timedelta(days=3)
+    span = (monday - week1_monday).days
+    week = span // 7 + 1
+
+    lines.append(f"ISO weeks run Monday to Sunday, so this week is {monday.isoformat()} "
+                 f"Mon to {sunday.isoformat()} Sun.")
+    lines.append(f"The Thursday of that week is {thursday.isoformat()}, which falls in "
+                 f"{iso_year}, so the ISO year is {iso_year}.")
+    lines.append(f"The first Thursday of {iso_year} is {first_thu.isoformat()}, so ISO "
+                 f"week 01 of {iso_year} starts {week1_monday.isoformat()} Mon.")
+    lines.append(f"{monday.isoformat()} minus {week1_monday.isoformat()} = {span} "
+                 f"{'day' if span == 1 else 'days'} = {span // 7} "
+                 f"{'week' if span // 7 == 1 else 'weeks'}, "
+                 f"so the week number is {week}.")
+
+    label = f"{iso_year}-W{week:02d}"
+    if label != _iso_label(target):
+        raise SolverError(f"F5 internal disagreement: first-Thursday {label} vs "
+                          f"isocalendar {_iso_label(target)} for {target}")
+    return label, lines
+
+
+# ---------------------------------------------------------------- entry point
+
+_DISPATCH = {"F1": solve_f1, "F2": solve_f2, "F3": solve_f3, "F4": solve_f4, "F5": solve_f5}
+
+
+def solve(params: dict) -> dict:
+    """{"answer_type", "answer", "working"} for one scenario. Raises on anything odd."""
+    fam = params.get("family")
+    if fam not in _DISPATCH:
+        raise SolverError(f"unknown family {fam!r}")
+    answer, working = _DISPATCH[fam](params)
+    return {"answer_type": ANSWER_TYPES[fam], "answer": answer, "working": working}
+
+
+def answer_of(params: dict) -> str:
+    return solve(params)["answer"]
+
+
+def _selftest() -> None:
+    ok = 0
+
+    # 1. The card's worked example. Ten business days after Friday 2026-11-20 is
+    #    Monday 2026-12-07; the walk skips Thanksgiving on Thursday 2026-11-26, and a
+    #    no-holiday walk would land on Friday 2026-12-04.
+    r = solve({"family": "F1", "anchor": "2026-11-20", "n": 10, "direction": "after"})
+    assert r["answer"] == "2026-12-07", r
+    assert any("Thanksgiving Day" in l for l in r["working"])
+    naive, _ = business_days_offset(date(2026, 11, 20), 10, True)   # with holidays
+    assert naive.isoformat() == "2026-12-07"
+    ok += 1
+
+    # 2. F1 backward, and n=1 on a Friday lands on the Monday.
+    assert answer_of({"family": "F1", "anchor": "2026-11-20", "n": 1,
+                      "direction": "after"}) == "2026-11-23"
+    assert answer_of({"family": "F1", "anchor": "2026-11-23", "n": 1,
+                      "direction": "before"}) == "2026-11-20"
+    # Anchor on a holiday still counts from the day after.
+    assert answer_of({"family": "F1", "anchor": "2026-07-03", "n": 1,
+                      "direction": "after"}) == "2026-07-06"
+    ok += 1
+
+    # 3. F1 rejects an out-of-cap n rather than answering it.
+    for bad in (0, 16):
+        try:
+            solve({"family": "F1", "anchor": "2026-11-20", "n": bad, "direction": "after"})
+            raise AssertionError(f"expected SolverError for n={bad}")
+        except SolverError:
+            pass
+    ok += 1
+
+    # 4. F2 forward across a month boundary with no adjustment.
+    r = solve({"family": "F2", "anchor": "2026-06-30", "n": 45, "direction": "after",
+               "roll": "forward"})
+    assert r["answer"] == "2026-08-14", r
+    assert (date(2026, 6, 30) + timedelta(days=45)).isoformat() == "2026-08-14"
+    # F2 landing on the Saturday of an observed-Friday holiday, both roll directions.
+    fwd = solve({"family": "F2", "anchor": "2026-07-01", "n": 3, "direction": "after",
+                 "roll": "forward"})
+    assert fwd["answer"] == "2026-07-06", fwd          # Sat 07-04 -> Mon 07-06
+    bwd = solve({"family": "F2", "anchor": "2026-07-01", "n": 3, "direction": "after",
+                 "roll": "backward"})
+    assert bwd["answer"] == "2026-07-02", bwd          # Sat 07-04 -> skip observed Fri 07-03
+    assert any("Independence Day" in l for l in bwd["working"])
+    ok += 1
+
+    # 5. F2 backward arithmetic matches a plain timedelta for every n in the cap.
+    for n in range(1, 61):
+        got, _ = _calendar_add_lines(date(2026, 8, 12), n, False)
+        assert got == date(2026, 8, 12) - timedelta(days=n), (n, got)
+        got, _ = _calendar_add_lines(date(2026, 1, 15), n, True)
+        assert got == date(2026, 1, 15) + timedelta(days=n), (n, got)
+    ok += 1
+
+    # 6. THE DST TRAP. Regression test for the bug the dual-solver gate caught.
+    ny = ZoneInfo("America/New_York")
+    a = datetime(2026, 10, 31, 22, 0, tzinfo=ny)
+    b = datetime(2026, 11, 1, 6, 0, tzinfo=ny)
+    assert (b - a) == timedelta(hours=8), "Python changed same-zone subtraction"
+    r = solve({"family": "F3",
+               "start": {"dt": "2026-10-31T22:00", "zone": "America/New_York"},
+               "end": {"dt": "2026-11-01T06:00", "zone": "America/New_York"}})
+    assert r["answer"] == "9:00", r
+    ok += 1
+
+    # 7. H:MM semantics: over 24 hours, no days component, no leading zero on hours.
+    assert format_hmm(0) == "0:00"
+    assert format_hmm(45) == "0:45"
+    assert format_hmm(9 * 60) == "9:00"
+    assert format_hmm(30 * 60 + 45) == "30:45"
+    assert format_hmm(100 * 60 + 5) == "100:05"
+    try:
+        format_hmm(-1)
+        raise AssertionError("negative elapsed must raise")
+    except SolverError:
+        pass
+    ok += 1
+
+    # 8. Endpoint existence and unambiguity, in both failure directions.
+    assert endpoint_is_unambiguous({"dt": "2026-11-01T06:00", "zone": "America/New_York"})
+    assert not endpoint_is_unambiguous(
+        {"dt": "2026-11-01T01:30", "zone": "America/New_York"}), "repeated hour"
+    assert not endpoint_is_unambiguous(
+        {"dt": "2026-03-08T02:30", "zone": "America/New_York"}), "spring-forward gap"
+    assert endpoint_is_unambiguous({"dt": "2026-06-15T12:00", "zone": "Asia/Kolkata"})
+    ok += 1
+
+    # 9. F3 across zones and across a spring-forward transition.
+    r = solve({"family": "F3",
+               "start": {"dt": "2026-03-07T20:00", "zone": "America/New_York"},
+               "end": {"dt": "2026-03-08T09:00", "zone": "America/New_York"}})
+    assert r["answer"] == "12:00", r     # 13 wall-clock hours, one hour skipped
+    r = solve({"family": "F3",
+               "start": {"dt": "2026-05-04T09:00", "zone": "America/Los_Angeles"},
+               "end": {"dt": "2026-05-05T01:30", "zone": "Asia/Tokyo"}})
+    # 2026-05-04 09:00 PDT = 16:00 UTC; 2026-05-05 01:30 JST = 2026-05-04 16:30 UTC
+    assert r["answer"] == "0:30", r
+    ok += 1
+
+    # 10. F4: semimonthly, moved to the prior business day.
+    r = solve({"family": "F4", "schedule": {"kind": "semimonthly", "day": 15},
+               "after": "2026-05-20", "adjust": "prior"})
+    assert r["answer"] == "2026-05-29", r     # nominal Sun 2026-05-31 -> Fri 2026-05-29
+    r = solve({"family": "F4", "schedule": {"kind": "month_end"},
+               "after": "2026-05-20", "adjust": "next"})
+    assert r["answer"] == "2026-06-01", r     # nominal Sun 2026-05-31 -> Mon 2026-06-01
+    r = solve({"family": "F4", "schedule": {"kind": "day_of_month", "day": 4},
+               "after": "2026-06-10", "adjust": "prior"})
+    assert r["answer"] == "2026-07-02", r     # nominal Sat 07-04 -> Fri 07-03 is the
+    #                                            observed holiday -> Thu 07-02
+    r = solve({"family": "F4", "schedule": {"kind": "quarter_end"},
+               "after": "2026-04-01", "adjust": "prior"})
+    assert r["answer"] == "2026-06-30", r
+    r = solve({"family": "F4", "schedule": {"kind": "nth_weekday", "weekday": 0, "n": 1},
+               "after": "2026-08-15", "adjust": "next"})
+    assert r["answer"] == "2026-09-08", r     # Mon 2026-09-07 is Labor Day -> Tue 09-08
+    ok += 1
+
+    # 11. F5 against isocalendar over a decade, boundaries included. solve_f5 already
+    #     raises on an internal disagreement, so this drives every day through it.
+    d = date(2020, 1, 1)
+    n = 0
+    while d <= date(2030, 12, 31):
+        lab = solve({"family": "F5", "kind": "of_date", "date": d.isoformat()})["answer"]
+        iso = d.isocalendar()
+        assert lab == f"{iso[0]}-W{iso[1]:02d}", (d, lab)
+        d += timedelta(days=1)
+        n += 1
+    assert n > 4000
+    assert solve({"family": "F5", "kind": "of_date",
+                  "date": "2026-11-20"})["answer"] == "2026-W47"
+    assert solve({"family": "F5", "kind": "of_date",
+                  "date": "2022-01-01"})["answer"] == "2021-W52"
+    assert solve({"family": "F5", "kind": "of_offset_days", "date": "2026-12-28",
+                  "offset_days": 7})["answer"] == "2027-W01"
+    assert solve({"family": "F5", "kind": "of_nth_weekday", "date": "2027-03-01",
+                  "weekday": 0, "n": 3})["answer"] == "2027-W11"
+    ok += 1
+
+    # 12. Unknown families and unknown kinds raise rather than returning a guess.
+    for bad in ({"family": "F9"},
+                {"family": "F5", "kind": "nope", "date": "2026-01-01"},
+                {"family": "F4", "schedule": {"kind": "nope"}, "after": "2026-01-01",
+                 "adjust": "prior"}):
+        try:
+            solve(bad)
+            raise AssertionError(f"expected SolverError for {bad}")
+        except SolverError:
+            pass
+    ok += 1
+
+    print(f"solver_a selftest: {ok}/12 OK")
+
+
+if __name__ == "__main__":
+    _selftest()