algorithm-discovery-engine 1.0.0__tar.gz → 1.0.1__tar.gz

{algorithm_discovery_engine-1.0.0 → algorithm_discovery_engine-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: algorithm-discovery-engine
-Version: 1.0.0
+Version: 1.0.1
 Summary: Multi-language algorithms & data structures solving engine (Java, C++, Rust, Python) with cross-language benchmarks and a local AI synthesizer that rediscovers algorithms from examples.
 Author: dsk-dev-ai
 License: MIT
@@ -208,11 +208,11 @@ Core logic lives in `gui/core.py` and is tested headlessly in CI (`-p gui` mypy
 Prebuilt on **GitHub Packages** (amd64 + arm64) — no install needed:
 
 ```sh
-docker pull ghcr.io/dsk-dev-ai/algorithm-discovery-engine:v1.0.0
-docker run --rm ghcr.io/dsk-dev-ai/algorithm-discovery-engine:v1.0.0 --smoke
+docker pull ghcr.io/dsk-dev-ai/algorithm-discovery-engine:v1.0.1
+docker run --rm ghcr.io/dsk-dev-ai/algorithm-discovery-engine:v1.0.1 --smoke
 ```
 
-Tags: `latest`, per-version (`v1.0.0`), and per-commit (`sha-<hash>`). The image runs
+Tags: `latest`, per-version (`v1.0.1`), and per-commit (`sha-<hash>`). The image runs
 the local algorithm synthesizer by default; override with any `python -m` command.
 
 ## Documentation

{algorithm_discovery_engine-1.0.0 → algorithm_discovery_engine-1.0.1}/README.md

@@ -185,11 +185,11 @@ Core logic lives in `gui/core.py` and is tested headlessly in CI (`-p gui` mypy
 Prebuilt on **GitHub Packages** (amd64 + arm64) — no install needed:
 
 ```sh
-docker pull ghcr.io/dsk-dev-ai/algorithm-discovery-engine:v1.0.0
-docker run --rm ghcr.io/dsk-dev-ai/algorithm-discovery-engine:v1.0.0 --smoke
+docker pull ghcr.io/dsk-dev-ai/algorithm-discovery-engine:v1.0.1
+docker run --rm ghcr.io/dsk-dev-ai/algorithm-discovery-engine:v1.0.1 --smoke
 ```
 
-Tags: `latest`, per-version (`v1.0.0`), and per-commit (`sha-<hash>`). The image runs
+Tags: `latest`, per-version (`v1.0.1`), and per-commit (`sha-<hash>`). The image runs
 the local algorithm synthesizer by default; override with any `python -m` command.
 
 ## Documentation

algorithm_discovery_engine-1.0.1/catalog/discoveries/report.json

@@ -0,0 +1,126 @@
+{
+  "generated_at": "2026-09-10T17:55:40Z",
+  "fuzz_per_target": 10,
+  "solved_catalog_problems": 10,
+  "targets": [
+    {
+      "id": "max_subarray",
+      "status": "verified",
+      "hidden": false,
+      "search_ms": 34257,
+      "curated_examples_pass": true,
+      "fuzz_examples_pass": true,
+      "fuzz_run": 10,
+      "source": "def discovered_max_subarray(arg):\n    if not arg:\n        return 0\n    s0 = arg[0]\n    s1 = 0\n    for i, x in enumerate(arg):\n        n = len(arg)\n        s1 = max(x, s1 + x)\n        s0 = max(s0, s1)\n    return s0",
+      "size_metric": 4,
+      "kind": "scan",
+      "strategy": "",
+      "time_class": "O(n), O(1) extra space",
+      "novelty": "rediscovered",
+      "novelty_note": "target already solved in the shared (4-language) catalog; this candidate matches the same contract all tier runners assert",
+      "signature": "max_subarray(nums: list[int]) -> int"
+    },
+    {
+      "id": "max_circular_subarray",
+      "status": "verified",
+      "hidden": false,
+      "search_ms": 0,
+      "curated_examples_pass": true,
+      "fuzz_examples_pass": true,
+      "fuzz_run": 10,
+      "source": "def discovered_max_circular_subarray(arg):\n    if not arg:\n        return 0\n    best_end = arg[0]\n    best = arg[0]\n    for x in arg[1:]:\n        best_end = max(x, best_end + x)\n        best = max(best, best_end)\n    total = sum(arg)\n    min_end = 0\n    min_wrap = 0\n    for x in arg:\n        min_end = min(0, min_end + x)\n        min_wrap = min(min_wrap, min_end)\n    return max(best, total - min_wrap, 0)",
+      "size_metric": 24,
+      "kind": "template:circular-kadane",
+      "strategy": "Kadane + minimum-window wrap (two passes)",
+      "time_class": "O(n), O(1) extra space",
+      "novelty": "new-to-catalog",
+      "novelty_note": "not part of the shared catalog yet - a candidate worth porting to the language tiers",
+      "signature": "max_circular_subarray(nums: list[int]) -> int"
+    },
+    {
+      "id": "best_time_buy_sell",
+      "status": "verified",
+      "hidden": false,
+      "search_ms": 31282,
+      "curated_examples_pass": true,
+      "fuzz_examples_pass": true,
+      "fuzz_run": 10,
+      "source": "def discovered_best_time_buy_sell(arg):\n    if not arg:\n        return 0\n    s0 = arg[0]\n    s1 = 0\n    for i, x in enumerate(arg):\n        n = len(arg)\n        s0 = min(s0, x)\n        s1 = max(s1, x - s0)\n    return s1",
+      "size_metric": 4,
+      "kind": "scan",
+      "strategy": "",
+      "time_class": "O(n), O(1) extra space",
+      "novelty": "new-to-catalog",
+      "novelty_note": "not part of the shared catalog yet - a candidate worth porting to the language tiers",
+      "signature": "best_time_buy_sell(prices: list[int]) -> int"
+    },
+    {
+      "id": "jump_game",
+      "status": "verified",
+      "hidden": false,
+      "search_ms": 30814,
+      "curated_examples_pass": true,
+      "fuzz_examples_pass": true,
+      "fuzz_run": 10,
+      "source": "def discovered_jump_game(arg):\n    s0 = 0\n    s1 = 0\n    for i, x in enumerate(arg):\n        n = len(arg)\n        s1 = max(s1, i - s0)\n        s0 = max(s0, i + x)\n    return s1 == 0",
+      "size_metric": 6,
+      "kind": "scan",
+      "strategy": "",
+      "time_class": "O(n), O(1) extra space",
+      "novelty": "new-to-catalog",
+      "novelty_note": "not part of the shared catalog yet - a candidate worth porting to the language tiers",
+      "signature": "jump_game(nums: list[int]) -> bool"
+    },
+    {
+      "id": "contains_duplicate",
+      "status": "verified",
+      "hidden": false,
+      "search_ms": 0,
+      "curated_examples_pass": true,
+      "fuzz_examples_pass": true,
+      "fuzz_run": 10,
+      "source": "def discovered_contains_duplicate(arg):\n    seen = set()\n    for x in arg:\n        if x in seen:\n            return True\n        seen.add(x)\n    return False",
+      "size_metric": 8,
+      "kind": "seen",
+      "strategy": "hash-set membership trace",
+      "time_class": "O(n), O(n) extra space",
+      "novelty": "new-to-catalog",
+      "novelty_note": "not part of the shared catalog yet - a candidate worth porting to the language tiers",
+      "signature": "contains_duplicate(nums: list[int]) -> bool"
+    },
+    {
+      "id": "majority_element",
+      "status": "verified",
+      "hidden": false,
+      "search_ms": 0,
+      "curated_examples_pass": true,
+      "fuzz_examples_pass": true,
+      "fuzz_run": 10,
+      "source": "def discovered_majority_element(arg):\n    candidate = arg[0]\n    count = 1\n    for x in arg[1:]:\n        if x == candidate:\n            count += 1\n        elif count == 0:\n            candidate = x\n            count = 1\n        else:\n            count -= 1\n    return candidate",
+      "size_metric": 15,
+      "kind": "vote",
+      "strategy": "Boyer-Moore majority voting",
+      "time_class": "O(n), O(1) extra space",
+      "novelty": "new-to-catalog",
+      "novelty_note": "not part of the shared catalog yet - a candidate worth porting to the language tiers",
+      "signature": "majority_element(nums: list[int]) -> int"
+    },
+    {
+      "id": "climbing_stairs",
+      "status": "verified",
+      "hidden": false,
+      "search_ms": 0,
+      "curated_examples_pass": true,
+      "fuzz_examples_pass": true,
+      "fuzz_run": 10,
+      "source": "def discovered_climbing_stairs(arg):\n    a, b = 1, 1\n    for _ in range(arg):\n        a, b = b, a + b\n    return a",
+      "size_metric": 9,
+      "kind": "fib",
+      "strategy": "two-token linear recurrence (Fibonacci)",
+      "time_class": "O(n), O(1) extra space",
+      "novelty": "new-to-catalog",
+      "novelty_note": "not part of the shared catalog yet - a candidate worth porting to the language tiers",
+      "signature": "climbing_stairs(n: int) -> int"
+    }
+  ]
+}

algorithm_discovery_engine-1.0.1/catalog/discoveries/report.md

@@ -0,0 +1,158 @@
+# Discovery report
+
+Fuzz cases per target: 10  ·  solved catalog problems: 10
+
+| target | status | strategy | size | novelty |
+| --- | --- | --- | ---: | --- |
+| max_subarray | verified |  | 4 | rediscovered |
+| max_circular_subarray | verified | Kadane + minimum-window wrap (two passes) | 24 | new-to-catalog |
+| best_time_buy_sell | verified |  | 4 | new-to-catalog |
+| jump_game | verified |  | 6 | new-to-catalog |
+| contains_duplicate | verified | hash-set membership trace | 8 | new-to-catalog |
+| majority_element | verified | Boyer-Moore majority voting | 15 | new-to-catalog |
+| climbing_stairs | verified | two-token linear recurrence (Fibonacci) | 9 | new-to-catalog |
+
+## max_subarray  (`scan`)
+
+`max_subarray(nums: list[int]) -> int`
+
+- Complexity: O(n), O(1) extra space
+- Novelty: rediscovered — target already solved in the shared (4-language) catalog; this candidate matches the same contract all tier runners assert
+- Verified on all curated examples and 10 fuzz inputs.
+
+```python
+def discovered_max_subarray(arg):
+    if not arg:
+        return 0
+    s0 = arg[0]
+    s1 = 0
+    for i, x in enumerate(arg):
+        n = len(arg)
+        s1 = max(x, s1 + x)
+        s0 = max(s0, s1)
+    return s0
+```
+
+## max_circular_subarray  (`template:circular-kadane`)
+
+`max_circular_subarray(nums: list[int]) -> int`
+
+- Complexity: O(n), O(1) extra space
+- Novelty: new-to-catalog — not part of the shared catalog yet - a candidate worth porting to the language tiers
+- Verified on all curated examples and 10 fuzz inputs.
+
+```python
+def discovered_max_circular_subarray(arg):
+    if not arg:
+        return 0
+    best_end = arg[0]
+    best = arg[0]
+    for x in arg[1:]:
+        best_end = max(x, best_end + x)
+        best = max(best, best_end)
+    total = sum(arg)
+    min_end = 0
+    min_wrap = 0
+    for x in arg:
+        min_end = min(0, min_end + x)
+        min_wrap = min(min_wrap, min_end)
+    return max(best, total - min_wrap, 0)
+```
+
+## best_time_buy_sell  (`scan`)
+
+`best_time_buy_sell(prices: list[int]) -> int`
+
+- Complexity: O(n), O(1) extra space
+- Novelty: new-to-catalog — not part of the shared catalog yet - a candidate worth porting to the language tiers
+- Verified on all curated examples and 10 fuzz inputs.
+
+```python
+def discovered_best_time_buy_sell(arg):
+    if not arg:
+        return 0
+    s0 = arg[0]
+    s1 = 0
+    for i, x in enumerate(arg):
+        n = len(arg)
+        s0 = min(s0, x)
+        s1 = max(s1, x - s0)
+    return s1
+```
+
+## jump_game  (`scan`)
+
+`jump_game(nums: list[int]) -> bool`
+
+- Complexity: O(n), O(1) extra space
+- Novelty: new-to-catalog — not part of the shared catalog yet - a candidate worth porting to the language tiers
+- Verified on all curated examples and 10 fuzz inputs.
+
+```python
+def discovered_jump_game(arg):
+    s0 = 0
+    s1 = 0
+    for i, x in enumerate(arg):
+        n = len(arg)
+        s1 = max(s1, i - s0)
+        s0 = max(s0, i + x)
+    return s1 == 0
+```
+
+## contains_duplicate  (`seen`)
+
+`contains_duplicate(nums: list[int]) -> bool`
+
+- Complexity: O(n), O(n) extra space
+- Novelty: new-to-catalog — not part of the shared catalog yet - a candidate worth porting to the language tiers
+- Verified on all curated examples and 10 fuzz inputs.
+
+```python
+def discovered_contains_duplicate(arg):
+    seen = set()
+    for x in arg:
+        if x in seen:
+            return True
+        seen.add(x)
+    return False
+```
+
+## majority_element  (`vote`)
+
+`majority_element(nums: list[int]) -> int`
+
+- Complexity: O(n), O(1) extra space
+- Novelty: new-to-catalog — not part of the shared catalog yet - a candidate worth porting to the language tiers
+- Verified on all curated examples and 10 fuzz inputs.
+
+```python
+def discovered_majority_element(arg):
+    candidate = arg[0]
+    count = 1
+    for x in arg[1:]:
+        if x == candidate:
+            count += 1
+        elif count == 0:
+            candidate = x
+            count = 1
+        else:
+            count -= 1
+    return candidate
+```
+
+## climbing_stairs  (`fib`)
+
+`climbing_stairs(n: int) -> int`
+
+- Complexity: O(n), O(1) extra space
+- Novelty: new-to-catalog — not part of the shared catalog yet - a candidate worth porting to the language tiers
+- Verified on all curated examples and 10 fuzz inputs.
+
+```python
+def discovered_climbing_stairs(arg):
+    a, b = 1, 1
+    for _ in range(arg):
+        a, b = b, a + b
+    return a
+```
+

algorithm_discovery_engine-1.0.1/catalog/discoveries/solutions/best_time_buy_sell.py

@@ -0,0 +1,10 @@
+def discovered_best_time_buy_sell(arg):
+    if not arg:
+        return 0
+    s0 = arg[0]
+    s1 = 0
+    for i, x in enumerate(arg):
+        n = len(arg)
+        s0 = min(s0, x)
+        s1 = max(s1, x - s0)
+    return s1

algorithm_discovery_engine-1.0.1/catalog/discoveries/solutions/climbing_stairs.py

@@ -0,0 +1,5 @@
+def discovered_climbing_stairs(arg):
+    a, b = 1, 1
+    for _ in range(arg):
+        a, b = b, a + b
+    return a

algorithm_discovery_engine-1.0.1/catalog/discoveries/solutions/contains_duplicate.py

@@ -0,0 +1,7 @@
+def discovered_contains_duplicate(arg):
+    seen = set()
+    for x in arg:
+        if x in seen:
+            return True
+        seen.add(x)
+    return False

algorithm_discovery_engine-1.0.1/catalog/discoveries/solutions/jump_game.py

@@ -0,0 +1,8 @@
+def discovered_jump_game(arg):
+    s0 = 0
+    s1 = 0
+    for i, x in enumerate(arg):
+        n = len(arg)
+        s1 = max(s1, i - s0)
+        s0 = max(s0, i + x)
+    return s1 == 0

algorithm_discovery_engine-1.0.1/catalog/discoveries/solutions/majority_element.py

@@ -0,0 +1,12 @@
+def discovered_majority_element(arg):
+    candidate = arg[0]
+    count = 1
+    for x in arg[1:]:
+        if x == candidate:
+            count += 1
+        elif count == 0:
+            candidate = x
+            count = 1
+        else:
+            count -= 1
+    return candidate

algorithm_discovery_engine-1.0.1/catalog/discoveries/solutions/max_circular_subarray.py

@@ -0,0 +1,15 @@
+def discovered_max_circular_subarray(arg):
+    if not arg:
+        return 0
+    best_end = arg[0]
+    best = arg[0]
+    for x in arg[1:]:
+        best_end = max(x, best_end + x)
+        best = max(best, best_end)
+    total = sum(arg)
+    min_end = 0
+    min_wrap = 0
+    for x in arg:
+        min_end = min(0, min_end + x)
+        min_wrap = min(min_wrap, min_end)
+    return max(best, total - min_wrap, 0)

algorithm_discovery_engine-1.0.1/catalog/discoveries/solutions/max_subarray.py

@@ -0,0 +1,10 @@
+def discovered_max_subarray(arg):
+    if not arg:
+        return 0
+    s0 = arg[0]
+    s1 = 0
+    for i, x in enumerate(arg):
+        n = len(arg)
+        s1 = max(x, s1 + x)
+        s0 = max(s0, s1)
+    return s0

algorithm_discovery_engine-1.0.1/catalog/discovery_targets.json

@@ -0,0 +1,238 @@
+{
+  "version": "1.0.0",
+  "_meta": "Discovery targets for the local synthesizer. Each entry carries curated I/O examples (the search learns from these), plus an oracle + fuzz generator used for out-of-sample verification. 'kind' selects which search backend runs.",
+  "targets": [
+    {
+      "id": "max_subarray",
+      "kind": "scan",
+      "signature": "max_subarray(nums: list[int]) -> int",
+      "description": "Maximum contiguous subarray sum (non-empty). Already solved in the shared catalog - the synthesizer must rediscover it from examples.",
+      "returns": "int",
+      "cases": [
+        {
+          "in": "1 -2 3 4|",
+          "out": "7"
+        },
+        {
+          "in": "-2 1 -3 4 -1 2 1 -5 4|",
+          "out": "6"
+        },
+        {
+          "in": "-1 -2 -3|",
+          "out": "-1"
+        },
+        {
+          "in": "5|",
+          "out": "5"
+        },
+        {
+          "in": "5 -2 3|",
+          "out": "6"
+        }
+      ],
+      "arg_types": [
+        "list"
+      ]
+    },
+    {
+      "id": "max_circular_subarray",
+      "kind": "template",
+      "signature": "max_circular_subarray(nums: list[int]) -> int",
+      "description": "Maximum sum over all circular subarrays (wrap-around allowed); empty selection allowed so all-negative input returns 0.",
+      "returns": "int",
+      "cases": [
+        {
+          "in": "5 -3 5|",
+          "out": "10"
+        },
+        {
+          "in": "8 -1 3 4|",
+          "out": "15"
+        },
+        {
+          "in": "-3 -2 -1|",
+          "out": "0"
+        },
+        {
+          "in": "1 -2 3 -2|",
+          "out": "3"
+        },
+        {
+          "in": "3 -1 2 -1|",
+          "out": "4"
+        },
+        {
+          "in": "6 -10 6|",
+          "out": "12"
+        }
+      ],
+      "arg_types": [
+        "list"
+      ]
+    },
+    {
+      "id": "best_time_buy_sell",
+      "kind": "scan",
+      "signature": "best_time_buy_sell(prices: list[int]) -> int",
+      "description": "Maximum profit from a single buy-then-sell pair; 0 when none is possible.",
+      "returns": "int",
+      "cases": [
+        {
+          "in": "7 1 5 3 6 4|",
+          "out": "5"
+        },
+        {
+          "in": "7 6 4 3 1|",
+          "out": "0"
+        },
+        {
+          "in": "1 2|",
+          "out": "1"
+        },
+        {
+          "in": "2 1|",
+          "out": "0"
+        },
+        {
+          "in": "3 2 6 5 0 3|",
+          "out": "4"
+        }
+      ],
+      "arg_types": [
+        "list"
+      ]
+    },
+    {
+      "id": "jump_game",
+      "kind": "scan",
+      "signature": "jump_game(nums: list[int]) -> bool",
+      "description": "Whether the last index is reachable by jumping at most nums[i] steps from each index.",
+      "returns": "bool",
+      "cases": [
+        {
+          "in": "2 3 1 1 4|",
+          "out": "true"
+        },
+        {
+          "in": "3 2 1 0 4|",
+          "out": "false"
+        },
+        {
+          "in": "0|",
+          "out": "true"
+        },
+        {
+          "in": "0 2 3|",
+          "out": "false"
+        },
+        {
+          "in": "1 2 0 1|",
+          "out": "true"
+        }
+      ],
+      "arg_types": [
+        "list"
+      ]
+    },
+    {
+      "id": "contains_duplicate",
+      "kind": "seen",
+      "signature": "contains_duplicate(nums: list[int]) -> bool",
+      "description": "Whether any value appears more than once.",
+      "returns": "bool",
+      "cases": [
+        {
+          "in": "1 2 3 1|",
+          "out": "true"
+        },
+        {
+          "in": "1 2 3 4|",
+          "out": "false"
+        },
+        {
+          "in": "1 1 1|",
+          "out": "true"
+        },
+        {
+          "in": "|",
+          "out": "false"
+        },
+        {
+          "in": "0 5 0|",
+          "out": "true"
+        }
+      ],
+      "arg_types": [
+        "list"
+      ]
+    },
+    {
+      "id": "majority_element",
+      "kind": "vote",
+      "signature": "majority_element(nums: list[int]) -> int",
+      "description": "Element occurring more than n//2 times (guaranteed present).",
+      "returns": "int",
+      "cases": [
+        {
+          "in": "3 2 3|",
+          "out": "3"
+        },
+        {
+          "in": "2 2 1 1 1 2 2|",
+          "out": "2"
+        },
+        {
+          "in": "5|",
+          "out": "5"
+        },
+        {
+          "in": "1 1 2|",
+          "out": "1"
+        },
+        {
+          "in": "-1 -1 3|",
+          "out": "-1"
+        }
+      ],
+      "arg_types": [
+        "list"
+      ]
+    },
+    {
+      "id": "climbing_stairs",
+      "kind": "fib",
+      "signature": "climbing_stairs(n: int) -> int",
+      "description": "Number of distinct ways to climb n stairs taking 1 or 2 steps at a time.",
+      "returns": "int",
+      "cases": [
+        {
+          "in": "0|",
+          "out": "1"
+        },
+        {
+          "in": "1|",
+          "out": "1"
+        },
+        {
+          "in": "2|",
+          "out": "2"
+        },
+        {
+          "in": "3|",
+          "out": "3"
+        },
+        {
+          "in": "4|",
+          "out": "5"
+        },
+        {
+          "in": "6|",
+          "out": "13"
+        }
+      ],
+      "arg_types": [
+        "int"
+      ]
+    }
+  ]
+}