algorithm-discovery-engine 1.0.0__py3-none-any.whl

synth/corpus.py

@@ -0,0 +1,222 @@
+"""Discovery targets, reference oracles, and fuzz generators.
+
+Curated targets live in ``catalog/discovery_targets.json``; every target maps
+to an oracle here (used as the truth source for fuzz verification) and a fuzz
+input generator.
+"""
+
+from __future__ import annotations
+
+import json
+import random
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parent.parent.parent
+
+PARSE_DELIM = "|"
+
+
+def parse_input(
+    spec: str, arg_types: list[str] | None = None
+) -> list[Any]:
+    """Parse a '|'-delimited spec into typed arguments.
+
+    Without ``arg_types`` a scalar token is parsed as ``int`` and multiple
+    tokens become a ``list[int]``. With ``arg_types`` each segment is read per
+    its declared type, so a single-element list like ``"0|"`` correctly
+    produces ``[0]`` (a one-arg list, not the scalar ``0``).
+    """
+    if arg_types is None:
+        return _parse_input_legacy(spec)
+    raw = spec.split(PARSE_DELIM)
+    if raw and raw[-1] == "":
+        raw.pop()
+    parsed: list[Any] = []
+    for piece, atype in zip(raw, arg_types, strict=True):
+        if atype == "int":
+            parsed.append(int(piece))
+        else:
+            parsed.append([] if not piece.strip() else [int(t) for t in piece.split()])
+    return parsed
+
+
+def _parse_input_legacy(spec: str) -> list[Any]:
+    """Legacy whitespace heuristic (scalar token -> int, more -> list)."""
+    parsed: list[Any] = []
+    for part in spec.split(PARSE_DELIM):
+        tokens = part.split()
+        if not tokens:
+            continue
+        if len(tokens) == 1:
+            token = tokens[0]
+            if token.lower() in {"true", "false"}:
+                parsed.append(token.lower() == "true")
+            else:
+                parsed.append(int(token))
+        else:
+            parsed.append([int(token) for token in tokens])
+    return parsed
+
+
+# --- oracles --------------------------------------------------------------------
+
+
+def _kadane(nums: list[int]) -> int:
+    best = nums[0] if nums else 0
+    running = 0
+    for value in nums:
+        running = max(value, running + value)
+        best = max(best, running)
+    return best
+
+
+def oracle_max_circular_subarray(nums: list[int]) -> int:
+    """Maximum circular subarray sum (empty selection allowed -> 0)."""
+    if not nums:
+        return 0
+    total = sum(nums)
+    if all(value < 0 for value in nums):
+        return 0
+    min_sub = _kadane([-value for value in nums])
+    return max(_kadane(nums), total + min_sub)
+
+
+def oracle_best_time_buy_sell(prices: list[int]) -> int:
+    """Maximum profit from one buy/sell; 0 if none possible."""
+    if len(prices) < 2:
+        return 0
+    best = 0
+    low = prices[0]
+    for price in prices[1:]:
+        low = min(low, price)
+        best = max(best, price - low)
+    return best
+
+
+def oracle_jump_game(nums: list[int]) -> bool:
+    """Whether the last index is reachable by jumping nums[i] steps."""
+    reach = 0
+    for i, value in enumerate(nums):
+        if i > reach:
+            return False
+        reach = max(reach, i + value)
+    return True
+
+
+def oracle_majority_element(nums: list[int]) -> int:
+    """Element appearing more than n//2 times (guaranteed in test inputs)."""
+    return sorted(nums)[len(nums) // 2]
+
+
+def oracle_contains_duplicate(nums: list[int]) -> bool:
+    """Whether any value appears more than once."""
+    return len(nums) != len(set(nums))
+
+
+def oracle_climbing_stairs(n: int) -> int:
+    """Ways to climb n stairs taking 1 or 2 steps."""
+    a, b = 1, 1
+    for _ in range(n):
+        a, b = b, a + b
+    return a
+
+
+ORACLES: dict[str, Callable[..., Any]] = {
+    "max_circular_subarray": oracle_max_circular_subarray,
+    "best_time_buy_sell": oracle_best_time_buy_sell,
+    "jump_game": oracle_jump_game,
+    "majority_element": oracle_majority_element,
+    "contains_duplicate": oracle_contains_duplicate,
+    "climbing_stairs": oracle_climbing_stairs,
+    "max_subarray": _kadane,
+}
+
+
+# --- fuzz generators -------------------------------------------------------------
+
+def _small_int_list(rng: random.Random, low: int, high: int) -> list[int]:
+    length = rng.randrange(0, 13)
+    return [rng.randrange(low, high + 1) for _ in range(length)]
+
+
+def fuzz_int_list(rng: random.Random) -> list[int]:
+    return _small_int_list(rng, -12, 12)
+
+
+def fuzz_prices(rng: random.Random) -> list[int]:
+    return _small_int_list(rng, 0, 12)
+
+
+def fuzz_reach(rng: random.Random) -> list[int]:
+    return _small_int_list(rng, 0, 5)
+
+
+def fuzz_majority(rng: random.Random) -> list[int]:
+    length = rng.randrange(1, 9)
+    token = rng.randrange(-6, 6)
+    majority_count = length // 2 + 1
+    fill = [rng.randrange(-6, 6) for _ in range(length - majority_count)]
+    out = [token] * majority_count + fill
+    rng.shuffle(out)
+    return out
+
+
+def fuzz_small_int(rng: random.Random) -> int:
+    return rng.randrange(0, 16)
+
+
+FUZZ: dict[str, Callable[[random.Random], Any]] = {
+    "max_circular_subarray": fuzz_int_list,
+    "best_time_buy_sell": fuzz_prices,
+    "jump_game": fuzz_reach,
+    "majority_element": fuzz_majority,
+    "contains_duplicate": fuzz_int_list,
+    "climbing_stairs": fuzz_small_int,
+    "max_subarray": fuzz_int_list,
+}
+
+# --- loading ----------------------------------------------------------------------
+
+DISCOVERY_TARGETS: dict[str, dict[str, Any]] = {}
+
+
+def parse_output(spec: str) -> Any:
+    """Parse an expected output token into bool/int."""
+    token = spec.strip()
+    if token.lower() in {"true", "false"}:
+        return token.lower() == "true"
+    return int(token)
+
+
+def load_targets() -> dict[str, dict[str, Any]]:
+    """Load ``catalog/discovery_targets.json`` once."""
+    if DISCOVERY_TARGETS:
+        return DISCOVERY_TARGETS
+    path = ROOT / "catalog" / "discovery_targets.json"
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    for target in payload["targets"]:
+        oracle_name = target.get("oracle", target["id"])
+        fuzz_name = target.get("fuzz", target["id"])
+        target["oracle"] = ORACLES[oracle_name]
+        target["fuzz"] = FUZZ[fuzz_name]
+        target["examples"] = [
+            (parse_input(case["in"], target.get("arg_types")), parse_output(case["out"]))
+            for case in target["cases"]
+        ]
+        DISCOVERY_TARGETS[target["id"]] = target
+    return DISCOVERY_TARGETS
+
+
+def fuzz_cases(target_id: str, count: int) -> list[tuple[list[Any], Any]]:
+    """Draw ``count`` fuzz cases verified against the target's oracle."""
+    target = load_targets()[target_id]
+    oracle = target["oracle"]
+    generator = target["fuzz"]
+    rng = random.Random(target_id + str(count))
+    cases: list[tuple[list[Any], Any]] = []
+    for _ in range(count):
+        inputs = [generator(rng)]
+        cases.append((inputs, oracle(*inputs)))
+    return cases

synth/discovery.py

@@ -0,0 +1,198 @@
+"""Discovery orchestrator: search, verify, classify, and report.
+
+For every target in ``catalog/discovery_targets.json``:
+
+1. Search for a candidate algorithm (grammar search or strategy template).
+2. Verify it on the curated examples **and** on out-of-sample fuzz inputs
+   whose expected outputs come from an independent reference oracle.
+3. Classify novelty (rediscovered vs. new to the solved catalog) and estimate
+   complexity.
+4. Persist ``catalog/discoveries/report.json``, ``report.md``, and a runnable
+   per-target solution module.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from typing import Any
+
+from synth import corpus, search
+
+ROOT = corpus.ROOT
+DISCOVERIES_DIR = ROOT / "catalog" / "discoveries"
+SOLUTIONS_DIR = DISCOVERIES_DIR / "solutions"
+
+FUZZ_COUNT = 60
+
+
+def _solved_catalog_ids() -> set[str]:
+    payload = json.loads((ROOT / "catalog" / "problems.json").read_text(encoding="utf-8"))
+    ids = {entry["id"] for entry in payload.get("algorithms", [])}
+    ids.update({entry["id"] for entry in payload.get("structures", [])})
+    return ids
+
+
+def _verify_curated(candidate: search.Candidate, target: dict[str, Any]) -> bool:
+    namespace: dict[str, Any] = {}
+    exec(compile(candidate.source, "<synth>", "exec"), namespace)
+    fn = namespace[candidate.function_name]
+    for inputs, expected in target["examples"]:
+        try:
+            if fn(*inputs) != expected:
+                return False
+        except Exception:  # pragma: no cover - defensive
+            return False
+    return True
+
+
+def _verify_fuzz(candidate: search.Candidate, target_id: str) -> tuple[bool, int]:
+    cases = corpus.fuzz_cases(target_id, FUZZ_COUNT)
+    namespace: dict[str, Any] = {}
+    exec(compile(candidate.source, "<synth>", "exec"), namespace)
+    fn = namespace[candidate.function_name]
+    for inputs, expected in cases:
+        try:
+            if fn(*inputs) != expected:
+                return False, -1
+        except Exception:  # pragma: no cover - defensive
+            return False, -1
+    return True, len(cases)
+
+
+def _classify(target_id: str, kind: str) -> dict[str, str]:
+        solved = _solved_catalog_ids()
+        if target_id in solved:
+            status = (
+                "rediscovered" if kind == "scan" else "rediscovered-via-template"
+            )
+            note = (
+                "target already solved in the shared (4-language) catalog; "
+                "this candidate matches the same contract all tier runners assert"
+            )
+        else:
+            status = "new-to-catalog"
+            note = (
+                "not part of the shared catalog yet "
+                "- a candidate worth porting to the language tiers"
+            )
+        return {"status": status, "note": note}
+
+
+def discover(
+    smoke: bool = False, scan_budget: int | None = None, fuzz_count: int | None = None
+) -> dict[str, Any]:
+    """Run the full discovery pass over every target."""
+    targets = corpus.load_targets()
+    solved = _solved_catalog_ids()
+    global FUZZ_COUNT
+    if fuzz_count is not None:
+        FUZZ_COUNT = fuzz_count
+
+    entries: list[dict[str, Any]] = []
+    for target_id, target in targets.items():
+        started = time.monotonic()
+        budget = 200_000 if smoke else (scan_budget or 600_000)
+        candidate = search.discover_for_target(target, scan_budget=budget)
+        elapsed = time.monotonic() - started
+        if candidate is None:
+            entries.append(
+                {
+                    "id": target_id,
+                    "status": "no-candidate-found",
+                    "kind": target["kind"],
+                    "search_ms": round(elapsed * 1000),
+                }
+            )
+            continue
+        curated_ok = _verify_curated(candidate, target)
+        fuzz_ok, fuzz_run = _verify_fuzz(candidate, target_id)
+        classification = _classify(target_id, candidate.kind)
+        entries.append(
+            {
+                "id": target_id,
+                "status": (
+                    "verified" if (curated_ok and fuzz_ok) else "candidate-rejected"
+                ),
+                "hidden": False,
+                "search_ms": round(elapsed * 1000),
+                "curated_examples_pass": curated_ok,
+                "fuzz_examples_pass": fuzz_ok,
+                "fuzz_run": fuzz_run,
+                "source": candidate.source.strip(),
+                "size_metric": candidate.nodes,
+                "kind": candidate.kind,
+                "strategy": candidate.params.get("strategy", ""),
+                "time_class": candidate.time_class,
+                "novelty": classification["status"],
+                "novelty_note": classification["note"],
+                "signature": target["signature"],
+            }
+        )
+
+    report: dict[str, Any] = {
+        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "fuzz_per_target": FUZZ_COUNT,
+        "solved_catalog_problems": len(solved),
+        "targets": entries,
+    }
+    _write_report(report)
+    return report
+
+
+def _write_report(report: dict[str, Any]) -> None:
+    DISCOVERIES_DIR.mkdir(parents=True, exist_ok=True)
+    SOLUTIONS_DIR.mkdir(parents=True, exist_ok=True)
+    (DISCOVERIES_DIR / "report.json").write_text(
+        json.dumps(report, indent=2) + "\n", encoding="utf-8"
+    )
+    for entry in report["targets"]:
+        if "source" in entry:
+            (SOLUTIONS_DIR / f"{entry['id']}.py").write_text(
+                entry["source"] + "\n", encoding="utf-8"
+            )
+    (DISCOVERIES_DIR / "report.md").write_text(_render_markdown(report), encoding="utf-8")
+
+
+def _render_markdown(report: dict[str, Any]) -> str:
+    lines = [
+        "# Discovery report",
+        "",
+        f"Fuzz cases per target: {report['fuzz_per_target']}  ·  "
+        f"solved catalog problems: {report['solved_catalog_problems']}",
+        "",
+        "| target | status | strategy | size | novelty |",
+        "| --- | --- | --- | ---: | --- |",
+    ]
+    for entry in report["targets"]:
+        lines.append(
+            "| {} | {} | {} | {} | {} |".format(
+                entry["id"],
+                entry["status"],
+                entry.get("strategy", "-"),
+                entry.get("size_metric", "-"),
+                entry.get("novelty", "-"),
+            )
+        )
+    lines.append("")
+    for entry in report["targets"]:
+        if "source" not in entry or entry["status"] != "verified":
+            continue
+        lines.extend(
+            [
+                f"## {entry['id']}  (`{entry['kind']}`)",
+                "",
+                f"`{entry['signature']}`",
+                "",
+                f"- Complexity: {entry['time_class']}",
+                f"- Novelty: {entry['novelty']} — {entry['novelty_note']}",
+                f"- Verified on {entry['curated_examples_pass'] and 'all curated examples'}"
+                f" and {entry['fuzz_run']} fuzz inputs.",
+                "",
+                "```python",
+                entry["source"],
+                "```",
+                "",
+            ]
+        )
+    return "\n".join(lines) + "\n"

synth/grammar.py

@@ -0,0 +1,174 @@
+"""Expression grammar for synthesized algorithms.
+
+A tiny, typed-free expression language used by the search backends. Every
+expression can be evaluated over a binding environment and printed back as
+Python source, so discovered candidates are always runnable and reviewable.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+# Hard negative/positive sentinels far from real inputs.
+NEG_INF = -(1 << 30)
+POS_INF = 1 << 30
+
+
+@dataclass(frozen=True)
+class Node:
+    """Immutable expression tree node.
+
+    ``op`` is either a literal value (int/str) or one of the operator names
+    below. ``args`` holds child nodes.
+    """
+
+    op: str | int
+    args: tuple[Node, ...] = ()
+
+
+def const(value: int | str) -> Node:
+    return Node(value)
+
+
+def var(name: str) -> Node:
+    return Node("var", (Node(name),))
+
+
+def call(name: str, *args: Node) -> Node:
+    return Node(name, args)
+
+
+# nodes available to a scanner program ---------------------------------------
+
+UNARY_OPS = {"neg", "abs"}
+BINARY_OPS = {"add", "sub", "mul", "fdiv", "mod", "min", "max"}
+CMP_OPS = {"lt", "gt", "le", "ge", "eq"}
+
+ALL_OPS = UNARY_OPS | BINARY_OPS | CMP_OPS
+
+# simple canonical variables a scan understands
+VARIABLES = {"i", "n", "x"}
+
+_OPERATOR_TO_PY = {
+    "neg": "(-{})",
+    "abs": "abs({})",
+    "add": "({} + {})",
+    "sub": "({} - {})",
+    "mul": "({} * {})",
+    "fdiv": "({} // {})",
+    "mod": "({} % {})",
+    "min": "min({}, {})",
+    "max": "max({}, {})",
+    "lt": "({} < {})",
+    "gt": "({} > {})",
+    "le": "({} <= {})",
+    "ge": "({} >= {})",
+    "eq": "({} == {})",
+}
+
+
+def evaluate(node: Node, env: dict[str, Any]) -> Any:
+    """Evaluate the expression tree over ``env``.
+
+    Division by zero and mod-by-zero short-circuit to a benign neutral value
+    so search does not crash on degenerate candidates.
+    """
+    op = node.op
+    if isinstance(op, int):
+        return op
+    if op == "var":
+        key = node.args[0].op
+        assert isinstance(key, str)
+        return env[key]
+    if op == "neg":
+        return -evaluate(node.args[0], env)
+    if op == "abs":
+        return abs(evaluate(node.args[0], env))
+    if op in BINARY_OPS or op in CMP_OPS:
+        left = evaluate(node.args[0], env)
+        right = evaluate(node.args[1], env)
+        if op == "add":
+            return left + right
+        if op == "sub":
+            return left - right
+        if op == "mul":
+            return left * right
+        if op == "fdiv":
+            if right == 0:
+                return left
+            sign = -1 if (left < 0) != (right < 0) else 1
+            return sign * (abs(left) // abs(right))
+        if op == "mod":
+            if right == 0:
+                return 0
+            sign = 1 if right > 0 else -1
+            return sign * (((left % abs(right)) + abs(right)) % abs(right))
+        if op == "min":
+            return min(left, right)
+        if op == "max":
+            return max(left, right)
+        if op == "lt":
+            return left < right
+        if op == "gt":
+            return left > right
+        if op == "le":
+            return left <= right
+        if op == "ge":
+            return left >= right
+        return left == right
+    raise ValueError(f"unknown node: {node}")
+
+
+def to_python(node: Node) -> str:
+    """Render the expression tree as Python source."""
+    op = node.op
+    if isinstance(op, int):
+        return repr(op)
+    if op == "var":
+        return str(node.args[0].op)
+    if op in UNARY_OPS:
+        return _OPERATOR_TO_PY[op].format(to_python(node.args[0]))
+    if op in BINARY_OPS or op in CMP_OPS:
+        return _OPERATOR_TO_PY[op].format(
+            to_python(node.args[0]), to_python(node.args[1])
+        )
+    raise ValueError(f"unknown node: {node}")
+
+
+def size(node: Node) -> int:
+    """Number of nodes in the tree (a cheap complexity metric)."""
+    return 1 + sum(size(child) for child in node.args)
+
+
+def tree_depth(node: Node) -> int:
+    """Tree depth (used for search budget pruning)."""
+    return 1 + max((tree_depth(child) for child in node.args), default=0)
+
+
+def grow(depth: int, variables: tuple[str, ...], constants: tuple[int, ...]) -> list[Node]:
+    """Enumerate all expressions up to ``depth`` over the given leaves."""
+    if depth <= 1:
+        return [var(name) for name in variables] + [const(c) for c in constants]
+    results = [var(name) for name in variables] + [const(c) for c in constants]
+    below = grow(depth - 1, variables, constants)
+    for name in UNARY_OPS:
+        for child in below:
+            results.append(call(name, child))
+    for name in BINARY_OPS | CMP_OPS:
+        for left in below:
+            for right in below:
+                results.append(call(name, left, right))
+    return results
+
+
+def dedupe_python(nodes: list[Node]) -> list[Node]:
+    """Drop nodes whose rendered Python source is identical (dedup + normalize)."""
+    seen: set[str] = set()
+    out: list[Node] = []
+    for node in nodes:
+        key = to_python(node)
+        if key not in seen:
+            seen.add(key)
+            out.append(node)
+    return out