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

algo_discovery/hypotheses.py

@@ -0,0 +1,251 @@
+"""Built-in mathematical hypotheses.
+
+Each hypothesis inspects an :class:`IntegerSequence` and reports a confidence
+in [0, 1] plus an optional next-term prediction.
+"""
+
+from __future__ import annotations
+
+from fractions import Fraction
+
+from algo_discovery.models import HypothesisScore, IntegerSequence
+
+
+class BaseHypothesis:
+    """Abstract base for a sequence hypothesis."""
+
+    name = "base"
+    description = ""
+
+    def detect(self, seq: IntegerSequence) -> HypothesisScore:
+        raise NotImplementedError
+
+
+class ConstantHypothesis(BaseHypothesis):
+    """All terms are equal."""
+
+    name = "constant"
+
+    def detect(self, seq: IntegerSequence) -> HypothesisScore:
+        equal = all(t == seq[0] for t in seq.terms)
+        conf = 1.0 if equal else 0.0
+        pred = seq[0] if equal else None
+        return HypothesisScore(self.name, conf, "c, c, c, ...", pred)
+
+
+class ArithmeticHypothesis(BaseHypothesis):
+    """Constant first difference (a, a+d, a+2d, ...)."""
+
+    name = "arithmetic"
+
+    def detect(self, seq: IntegerSequence) -> HypothesisScore:
+        diffs = {seq[i + 1] - seq[i] for i in range(len(seq) - 1)}
+        if len(diffs) == 1:
+            d = next(iter(diffs))
+            return HypothesisScore(
+                self.name, 1.0, f"a[i] = a[0] + {d}·i", seq[-1] + d
+            )
+        return HypothesisScore(self.name, 0.0)
+
+
+class GeometricHypothesis(BaseHypothesis):
+    """Constant ratio (a, a·r, a·r², ...) over the rationals."""
+
+    name = "geometric"
+
+    def detect(self, seq: IntegerSequence) -> HypothesisScore:
+        if any(t == 0 for t in seq.terms):
+            return HypothesisScore(self.name, 0.0)
+        ratios = {
+            Fraction(seq[i + 1], seq[i]) for i in range(len(seq) - 1)
+        }
+        if len(ratios) == 1:
+            r = next(iter(ratios))
+            num, den = r.numerator, r.denominator
+            pred = seq[-1] * num // den if (seq[-1] * num) % den == 0 else None
+            return HypothesisScore(
+                self.name, 1.0, f"a[i] = a[0] · ({num}/{den})^i", pred,
+            )
+        return HypothesisScore(self.name, 0.0)
+
+
+class QuadraticHypothesis(BaseHypothesis):
+    """Constant non-zero second difference => degree-2 polynomial in the index."""
+
+    name = "quadratic"
+
+    def detect(self, seq: IntegerSequence) -> HypothesisScore:
+        if len(seq) < 3:
+            return HypothesisScore(self.name, 0.0)
+        first = [seq[i + 1] - seq[i] for i in range(len(seq) - 1)]
+        second = {first[i + 1] - first[i] for i in range(len(first) - 1)}
+        if len(second) == 1:
+            d2 = next(iter(second))
+            if d2 == 0:
+                # zero curvature is just a linear (arithmetic) pattern
+                return HypothesisScore(self.name, 0.0)
+            ndiff = first[-1] + d2
+            return HypothesisScore(self.name, 1.0, f"Δ² = {d2}", seq[-1] + ndiff)
+        return HypothesisScore(self.name, 0.0)
+
+
+class PowerOfTwoHypothesis(BaseHypothesis):
+    """Terms are exact powers of 2 (a[i] = 2^k)."""
+
+    name = "powers-of-two"
+
+    @staticmethod
+    def _is_power_of_two(value: int) -> bool:
+        return value > 0 and (value & (value - 1)) == 0
+
+    def detect(self, seq: IntegerSequence) -> HypothesisScore:
+        if any(not self._is_power_of_two(t) for t in seq.terms):
+            return HypothesisScore(self.name, 0.0)
+        # consecutive powers of 2: each term is double the previous
+        consecutive = all(
+            seq.terms[i + 1] == 2 * seq.terms[i] for i in range(len(seq) - 1)
+        )
+        return HypothesisScore(self.name, 1.0, "powers of 2",
+                               2 * seq[-1] if consecutive else None)
+
+
+class CubicHypothesis(BaseHypothesis):
+    """Constant third difference => degree-3 polynomial in the index."""
+
+    name = "cubic"
+
+    def detect(self, seq: IntegerSequence) -> HypothesisScore:
+        if len(seq) < 4:
+            return HypothesisScore(self.name, 0.0)
+
+        def diffs(values: list[int]) -> list[int]:
+            return [values[i + 1] - values[i] for i in range(len(values) - 1)]
+
+        first = diffs(list(seq.terms))
+        second = diffs(first)
+        third = diffs(second)
+        if len(set(third)) == 1:
+            d3 = third[0]
+            if d3 == 0:
+                return HypothesisScore(self.name, 0.0)
+            nd2 = second[-1] + d3
+            nd1 = first[-1] + nd2
+            return HypothesisScore(self.name, 1.0, f"Δ³ = {d3}", seq[-1] + nd1)
+        return HypothesisScore(self.name, 0.0)
+
+
+class FibonacciLikeHypothesis(BaseHypothesis):
+    """Every term (past the first two) equals the sum of its two predecessors."""
+
+    name = "fibonacci-like"
+
+    def detect(self, seq: IntegerSequence) -> HypothesisScore:
+        terms = seq.terms
+        for i in range(2, len(terms)):
+            if terms[i] != terms[i - 1] + terms[i - 2]:
+                return HypothesisScore(self.name, 0.0)
+        return HypothesisScore(self.name, 1.0, "a[i] = a[i-1] + a[i-2]",
+                                terms[-1] + terms[-2])
+
+
+class RecurrenceLinearHypothesis(BaseHypothesis):
+    """Best-fit linear recurrence a[i] = p·a[i-1] + q (solve exactly when possible)."""
+
+    name = "linear-recurrence"
+
+    def detect(self, seq: IntegerSequence) -> HypothesisScore:
+        terms = seq.terms
+        # solve for (p, q) from the first two constraints
+        # a1 = p*a0 + q ; a2 = p*a1 + q  =>  p = (a2 - a1)/(a1 - a0)
+        denom = terms[1] - terms[0]
+        if denom == 0:
+            if terms[2] == terms[1]:
+                return HypothesisScore(
+                    self.name, 1.0, "a[i] = a[i-1] (constant)", terms[-1]
+                )
+            return HypothesisScore(self.name, 0.0)
+        if (terms[2] - terms[1]) % denom != 0:
+            return HypothesisScore(self.name, 0.0)
+        p = (terms[2] - terms[1]) // denom
+        q = terms[1] - p * terms[0]
+        for i in range(3, len(terms)):
+            if terms[i] != p * terms[i - 1] + q:
+                return HypothesisScore(self.name, 0.0)
+        return HypothesisScore(
+            self.name, 1.0, f"a[i] = {p}·a[i-1] + {q}",
+            p * terms[-1] + q,
+        )
+
+
+class PrimeHypothesis(BaseHypothesis):
+    """Terms are consecutive (or non-decreasing) primes."""
+
+    name = "primes"
+
+    @staticmethod
+    def _is_prime(value: int) -> bool:
+        if value < 2:
+            return False
+        if value < 4:
+            return True
+        if value % 2 == 0 or value % 3 == 0:
+            return False
+        i = 5
+        while i * i <= value:
+            if value % i == 0 or value % (i + 2) == 0:
+                return False
+            i += 6
+        return True
+
+    def detect(self, seq: IntegerSequence) -> HypothesisScore:
+        if any(not self._is_prime(t) for t in seq.terms):
+            return HypothesisScore(self.name, 0.0)
+        consecutive = all(
+            all(not self._is_prime(c) for c in range(seq[i] + 1, seq[i + 1]))
+            for i in range(len(seq) - 1)
+        ) if all(seq[i] < seq[i + 1] for i in range(len(seq) - 1)) else False
+        conf = 1.0 if consecutive else 0.7
+        return HypothesisScore(self.name, conf, "all terms are prime")
+
+
+class AlternatingHypothesis(BaseHypothesis):
+    """Strictly alternating signs with non-decreasing magnitudes."""
+
+    name = "alternating"
+
+    def detect(self, seq: IntegerSequence) -> HypothesisScore:
+        mags = [abs(t) for t in seq.terms]
+        signs = [t > 0 for t in seq.terms]
+        strictly_alt = all(signs[i] != signs[i + 1] for i in range(len(signs) - 1))
+        monotone_mag = all(mags[i] <= mags[i + 1] for i in range(len(mags) - 1))
+        conf = 1.0 if strictly_alt and monotone_mag else 0.0
+        mag_growth = mags[-1] - mags[-2]
+        pred = seq[-1] - mag_growth if signs[-1] else seq[-1] + mag_growth
+        return HypothesisScore(self.name, conf, "sign alternates", pred)
+
+
+ALL_HYPOTHESES: tuple[type[BaseHypothesis], ...] = (
+    ConstantHypothesis,
+    ArithmeticHypothesis,
+    GeometricHypothesis,
+    QuadraticHypothesis,
+    CubicHypothesis,
+    PowerOfTwoHypothesis,
+    FibonacciLikeHypothesis,
+    RecurrenceLinearHypothesis,
+    PrimeHypothesis,
+    AlternatingHypothesis,
+)
+
+
+def build_hypotheses(extra: list[BaseHypothesis] | None = None) -> list[BaseHypothesis]:
+    """Instantiate the standard hypothesis set plus any extras."""
+    instances: list[BaseHypothesis] = [cls() for cls in ALL_HYPOTHESES]
+    if extra:
+        instances.extend(extra)
+    return instances
+
+
+def describe(hypothesis: BaseHypothesis) -> str:
+    """Human description used by the CLI/reporter."""
+    return f"{hypothesis.name}: {hypothesis.description or hypothesis.name}"

algo_discovery/models.py

@@ -0,0 +1,63 @@
+"""Core data model for sequences and discovery results."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class IntegerSequence:
+    """An immutable integer sequence.
+
+    A sequence of at least three integers (the framework needs enough
+    evidence to distinguish hypotheses). Empty and length-1/2 sequences are
+    rejected at construction.
+    """
+
+    terms: tuple[int, ...]
+
+    def __init__(self, terms: tuple[int, ...] | list[int]) -> None:
+        if len(terms) < 3:
+            raise ValueError("a sequence needs at least 3 terms")
+        object.__setattr__(self, "terms", tuple(terms))
+
+    def __len__(self) -> int:
+        return len(self.terms)
+
+    def __getitem__(self, index: int) -> int:
+        return self.terms[index]
+
+    @property
+    def span(self) -> int:
+        """max - min over the whole sequence (a crude trend measure)."""
+        return max(self.terms) - min(self.terms)
+
+
+@dataclass
+class HypothesisScore:
+    """Confidence of a single hypothesis against a sequence."""
+
+    name: str
+    confidence: float
+    detail: str = ""
+    prediction: int | None = None
+
+    def __post_init__(self) -> None:
+        self.confidence = round(max(0.0, min(1.0, self.confidence)), 4)
+
+
+@dataclass
+class DiscoveryResult:
+    """Ranked set of hypotheses for one sequence."""
+
+    sequence: IntegerSequence
+    scores: list[HypothesisScore] = field(default_factory=list)
+
+    @property
+    def best(self) -> HypothesisScore | None:
+        ranked = self.ranked
+        return ranked[0] if ranked else None
+
+    @property
+    def ranked(self) -> list[HypothesisScore]:
+        return sorted(self.scores, key=lambda s: s.confidence, reverse=True)

algorithm_discovery_engine-1.0.0.dist-info/METADATA

@@ -0,0 +1,287 @@
+Metadata-Version: 2.5
+Name: algorithm-discovery-engine
+Version: 1.0.0
+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
+License-File: LICENSE
+Keywords: ai,algorithm-discovery,algorithms,automated-discovery,benchmark,cpp,data-structures,developer-tools,education,java,learning,machine-learning,open-source,python,rust,scientific-computing,sequence-analysis,synthesizer
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Java
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Education
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# algorithm-discovery-engine
+
+**One catalog, four languages, zero dependencies — and a synthesizer that rediscovers the algorithms for you.**
+
+[![CI](https://github.com/dsk-dev-ai/algorithm-discovery-engine/actions/workflows/ci.yml/badge.svg)](https://github.com/dsk-dev-ai/algorithm-discovery-engine/actions/workflows/ci.yml)
+[![Stars](https://img.shields.io/github/stars/dsk-dev-ai/algorithm-discovery-engine?style=flat-square&logo=github&logoColor=white)](https://github.com/dsk-dev-ai/algorithm-discovery-engine/stargazers)
+[![Forks](https://img.shields.io/github/forks/dsk-dev-ai/algorithm-discovery-engine?style=flat-square&logo=github&logoColor=white)](https://github.com/dsk-dev-ai/algorithm-discovery-engine/forks)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![Last commit](https://img.shields.io/github/last-commit/dsk-dev-ai/algorithm-discovery-engine?style=flat-square&logo=git&logoColor=white)]()
+[![Docs](https://img.shields.io/badge/docs-live-blue?style=flat-square&logo=materialformkdocs&logoColor=white)](https://dsk-dev-ai.github.io/algorithm-discovery-engine/)
+[![GHCR](https://img.shields.io/badge/container-ghcr.io-lightgrey?style=flat-square&logo=docker&logoColor=white)](https://github.com/dsk-dev-ai/algorithm-discovery-engine/pkgs/container/algorithm-discovery-engine)
+[![GUI](https://img.shields.io/badge/available-gui_tkinter-blueviolet?style=flat-square)](#desktop-gui)
+[![Sponsor](https://img.shields.io/badge/%E2%9D%A4%EF%B8%8F-Sponsor-red?style=flat-square&logo=githubsponsors&logoColor=white)](https://github.com/sponsors/dsk-dev-ai)
+
+**Python** · **Java** · **C++** · **Rust**
+
+<img src=".github/social-preview.png" alt="algorithm-discovery-engine social preview" width="100%" />
+
+</div>
+
+---
+
+**The same algorithms and data structures, solved, tested, and benchmarked in Java, C++,
+Rust, and Python**, with one `catalog/problems.json` as the single source of truth and
+byte-identical generated test vectors across every language. On top sits a local
+**algorithm synthesizer** that discovers verified algorithms (Kadane, buy-and-sell, jump
+game) from input/output examples alone — no APIs, no model calls.
+
+## Features
+
+- **Multi-language solving engine** — 10 algorithms + 6 data structures implemented in
+  Java, C++17, Rust, and Python (regular + optimized advanced tiers).
+- **Cross-language benchmarks** — a single harness times all four tiers; compare
+  strategies (Java's hash-map two-sum vs. the quadratic scans in C++/Rust).
+- **Local algorithm synthesizer** — grammar-based search + strategy templates that
+  rediscover known algorithms and surface novel ones, fuzz-verified out-of-sample.
+- **Automated mathematical pattern discovery** — the original engine: feed in a
+  sequence, get ranked hypotheses (arithmetic, geometric, quadratic, Fibonacci-like) and
+  next-term predictions.
+- **Zero dependencies per language** — no framework, no package, no JIT magic; pure
+  standard library in all four tiers.
+- **Desktop GUI** — a Tkinter app (`python -m gui`) built on the standard library only;
+  core logic is headless-tested in CI.
+- **Generated-then-committed test vectors** — identical tests enforced by CI in every
+  language; a single `--check` keeps them in sync with the catalog.
+- **CI-green by default** — grid of Python 3.10–3.13, Java 21, GCC C++17, stable Rust,
+  discovery-smoke, GUI-core smoke, and a strict docs build.
+
+## Quick start
+
+```sh
+git clone https://github.com/dsk-dev-ai/algorithm-discovery-engine.git
+cd algorithm-discovery-engine
+
+python engine/runner.py test        # build + run the catalog suite in all 4 languages
+python engine/runner.py bench       # benchmark all tiers, side by side
+python engine/runner.py discover    # synthesize + verify algorithms from examples
+python -m gui                       # open the desktop app
+```
+
+No install required — Python ≥ 3.10 and (for the non-Python tiers) a JDK, a C++17
+compiler, and the Rust toolchain.
+
+## The multi-language engine
+
+### Catalog
+
+`catalog/problems.json` is the source of truth. Every algorithm and structure carries a
+shared test vector set asserted in **all four languages**.
+
+| Algorithms (10)                                          | Data structures (6)                              |
+| -------------------------------------------------------- | ------------------------------------------------ |
+| `two_sum`, `binary_search`, `merge_sort`, `quick_sort`    | `stack`, `queue`, `linked_list`, `bst`           |
+| `max_subarray`, `lcs`, `knapsack_01`, `edit_distance`     | `trie`, `min_heap`                               |
+| `graph_bfs`, `graph_dfs`                                  |                                                  |
+
+### Language tiers
+
+```mermaid
+flowchart LR
+    C[ catalog/problems.json ] --> G[ engine/gen_tests.py ]
+    G --> J[Java tests] & P[Python tests] & R[Rust tests] & X[C++ tests]
+    J -. reference impl .-> P
+```
+
+| Tier   | Location                 | Approach                                             |
+| ------ | ------------------------ | ---------------------------------------------------- |
+| Java   | `languages/java/`        | OO reference implementations                         |
+| C++    | `languages/cpp/`         | modern C++17, RAII, iterators                        |
+| Rust   | `languages/rust/`        | ownership-safe, zero dependencies                    |
+| Python | `src/ads/`               | regular + advanced (`*_advanced`, mypy strict)       |
+
+### Sample benchmark (microseconds, lower is better)
+
+```
+algorithm             Python        Java         C++        Rust
+merge_sort           928,850      85,358      66,972      39,647
+quick_sort           702,918      41,562      22,942      17,610
+max_subarray         444,168      17,881       9,702          78
+```
+
+> Languages may pick different strategies for the same problem (Java's `two_sum` uses a
+> hash map; C++/Rust use a quadratic scan) — the table is a trade-off showcase, not an
+> exact contest.
+
+## The synthesizer (the interesting part)
+
+`src/synth/` searches for candidate algorithms from input/output examples and verifies
+them out-of-sample before reporting anything.
+
+- **Grammar search** (`scan`): enumerates single-pass "scanner" programs until one
+  matches the curated examples *and* 60 fuzzed inputs against an independent oracle.
+  Kadane, buy-and-sell, and jump-game fall out of examples alone.
+- **Strategy templates** (`vote`, `seen`, `fib`, `circular-kadane`): Boyer-Moore
+  voting, hash-set membership, Fibonacci pumping, circular Kadane — all still
+  fuzz-verified.
+- **Novelty classification**: `rediscovered` (already in the catalog) vs.
+  `new-to-catalog` (a candidate worth porting to the four tiers).
+
+Current smoke run: **7 targets · 7 verified · 0 rejected**.
+
+```sh
+uv run python -m synth discover --smoke   # ~2 min, CI-friendly
+uv run python -m synth discover           # full pass
+uv run python -m synth discover --print   # include full report JSON
+```
+
+Output lands in `catalog/discoveries/`: `report.json`, `report.md`, and runnable
+`solutions/*.py`.
+
+A discovered jump-game scanner (verified on examples + fuzz):
+
+```python
+def discovered_jump_game(arg):
+    s0 = 0
+    s1 = 0
+    for i, x in enumerate(arg):
+        s1 = max(s1, i - s0)   # how far the current reach overshoots index i
+        s0 = max(s0, i + x)    # extend the reach
+    return s1 == 0
+```
+
+## Pattern discovery (original framework)
+
+```python
+from algo_discovery import DiscoveryEngine
+
+result = DiscoveryEngine().discover((1, 4, 9, 16, 25))
+print(result.best.name)       # "quadratic"
+print(result.best.prediction) # 36
+```
+
+10 built-in hypotheses (arithmetic, geometric, quadratic, cubic, powers-of-two,
+Fibonacci-like, affine recurrences, prime, alternating-sign, constant) with confidence,
+explanation, and next-term prediction.
+
+```sh
+uv run python -m algo_discovery 1 4 9 16
+```
+
+## Desktop GUI
+
+A small **Tkinter** desktop app (no third-party runtime dependencies) wraps the
+three engines behind a clean dark-themed interface:
+
+```sh
+python -m gui                   # launch from the repo root
+python engine/runner.py gui     # same thing via the dispatcher
+ade-gui                         # if installed with pip/uv
+```
+
+| Tab               | What it does                                                           |
+| ----------------- | ---------------------------------------------------------------------- |
+| **Discover**      | Run the synthesizer (smoke/full), view the per-target verified table, open the report. |
+| **Pattern discovery** | Enter an integer sequence, discover ranked hypotheses with next-term predictions.    |
+| **Engine**        | Check vectors, run pytest, build all tiers, benchmark, open docs/GitHub links.       |
+
+Core logic lives in `gui/core.py` and is tested headlessly in CI (`-p gui` mypy
++ `pytest -q tests/test_gui.py`).
+
+## Container image
+
+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
+```
+
+Tags: `latest`, per-version (`v1.0.0`), and per-commit (`sha-<hash>`). The image runs
+the local algorithm synthesizer by default; override with any `python -m` command.
+
+## Documentation
+
+Full docs: **https://dsk-dev-ai.github.io/algorithm-discovery-engine/**
+
+Build locally:
+
+```sh
+uv sync --group docs
+uv run mkdocs serve          # live preview at http://127.0.0.1:8000
+```
+
+## Development
+
+```sh
+uv sync --group dev --group docs
+uv run pytest -q               # 118+ tests (catalog + synthesizer + GUI core)
+uv run ruff check src tests
+uv run mypy -p algo_discovery -p ads -p synth -p gui
+uv run python -m gui --selftest           # headless GUI smoke
+uv run mkdocs build --strict             # documentation builds cleanly
+python engine/runner.py check   # keep generated vectors in sync before committing
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the full checklist and how to add a new
+catalog problem or a new discovery target.
+
+## Structure
+
+```
+catalog/problems.json            single source of truth (tests + examples)
+catalog/discovery_targets.json   discovery targets (curated examples + oracles)
+catalog/discoveries/             synthesizer reports + discovered solutions
+engine/gen_tests.py              generates identical test vectors per language
+engine/runner.py                 build / test / benchmark / synthesize dispatcher
+src/ads/                         Python solving engine (regular + advanced)
+src/algo_discovery/              pattern-discovery framework (original)
+src/synth/                       local algorithm synthesizer
+src/gui/                         Tkinter desktop app (stdlib only)
+docs/                            documentation site (MkDocs Material)
+languages/java/src/ads/          Java tier (+ TestRunner, Benchmark)
+languages/cpp/include/ads/       C++17 headers (+ tests, bench)
+languages/rust/src/              Rust tier (+ examples/benchmark.rs)
+```
+
+## Roadmap
+
+- Port `new-to-catalog` discoveries (buy-and-sell, jump game, circular Kadane) into the
+  four language tiers as first-class catalog problems.
+- Grow the discovery target corpus (graphs, DP, geometry) and tighten the synthesis
+  budget so full passes match CI time.
+- Add GitHub Actions generating the social-preview benchmark delta on every push.
+
+## Sponsor
+
+algorithm-discovery-engine is built and maintained by
+[Darshan Kachare](https://github.com/dsk-dev-ai) through
+[NextGenAI Labs](https://github.com/sponsors/dsk-dev-ai).
+
+Sponsorship supports development infrastructure, documentation, and long-term
+maintenance of this open-source platform.
+
+<a href="https://github.com/sponsors/dsk-dev-ai">
+  <img src="https://img.shields.io/badge/%E2%9D%A4%EF%B8%8F-Sponsor_on_GitHub-red?style=for-the-badge&logo=githubsponsors&logoColor=white" alt="Sponsor algorithm-discovery-engine"/>
+</a>
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

algorithm_discovery_engine-1.0.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+ads/__init__.py,sha256=Nsr28Xvn69gSxmYmtWrWesQrW8mi3dB1lJbuddatnXQ,1985
+ads/benchmark.py,sha256=34WfmLEymU9i_dvtkBpY6UgU3D1qg1B4zBZfQINh0go,2437
+ads/problems.py,sha256=ndOQjzPdC5A6rVDP-zYZIrc4Y6CVuc2-pac8v9B8FnA,6005
+ads/problems_advanced.py,sha256=z9SEy6OIXcAT3eZg-CSCVYoHC95vz67sjP8K6qNhToE,6615
+ads/structures.py,sha256=3tSjZo1ufZ8IGjShRmuDCDW_p0pUNJv8ZeLl02vgu8s,9782
+ads/structures_advanced.py,sha256=XrhuTL2AGpwDG35BAOoiNjCUqvLcXbJXDia5_zwYki8,11223
+algo_discovery/__init__.py,sha256=0wkXLuFwo-ceK20AOzr2yiBd2xoQ1bYwfPDVFHBeWdI,575
+algo_discovery/__main__.py,sha256=nL83Qb7NliO_tf5LcnEuYFWsDGbjnwfBb_OkqqwRRSA,1112
+algo_discovery/engine.py,sha256=puGgTpiPr3FY1mWOILlqo6jZ7AmsEbvbSFVidq3ddTQ,2062
+algo_discovery/features.py,sha256=eE9artdPffzCPgFnc6bH05I1b4v4aUUGJJxSS2sWOAg,3780
+algo_discovery/hypotheses.py,sha256=Dz4fDb519Glrh6DugkNFvlf6g5noEns_Cf2VwUOlMQU,8686
+algo_discovery/models.py,sha256=qfJXO1jWZLg8mH0KzQWkuS6Ry-DdBhhvGtEF8DztmlI,1720
+gui/__init__.py,sha256=PC5uF1IJSvyzLHV0zIky0OL8_c3Pz7bQiaupvRQq9wM,108
+gui/__main__.py,sha256=rhM-baS6i5YpxD5lwKpJo3yjUH3fK3eVFLkSry38FH4,603
+gui/app.py,sha256=CcG_U9qRbZTRQLpqT917n5rOD6QqtvFKc-0m9JeNJvg,15066
+gui/core.py,sha256=XZkPIP5-pYLiTXs1CT1kI_ZYhjefQQ5uZe80oHg7Dn8,4962
+synth/__init__.py,sha256=kURnZrnKktKr-YRkqmNVER36E8cn2Z9f4_rqqMCLMGI,720
+synth/__main__.py,sha256=mq6aMOLoL2i7nOEhQWGRtmVciSn6ftwjcX-fZgUnpb8,1950
+synth/corpus.py,sha256=ew9FfxEBB_L5I2vtC_BLwxwusiRMaQgdvR5OtEUUWQM,6832
+synth/discovery.py,sha256=qCGyKOxmJR_8JqFKLVOG8iBxkcziQH-7km6cIxt6Okg,7107
+synth/grammar.py,sha256=3brCBakaYkTA_78tmnuO7IVaBlE97K5f7RHABepnb0c,5107
+synth/search.py,sha256=OWY7lCVmd68RVyWFaMdBth3tDsd1gRtgoByBCj_rHcw,14324
+algorithm_discovery_engine-1.0.0.dist-info/METADATA,sha256=NpKKs8jAWz_-tMfc0cYnjqFNMiDYNgXil77H65ePVT4,13268
+algorithm_discovery_engine-1.0.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+algorithm_discovery_engine-1.0.0.dist-info/entry_points.txt,sha256=9Xu5qHUd2jvpS5KzjBQsJjGkO4i3vZoDkP1oKE_6KSA,41
+algorithm_discovery_engine-1.0.0.dist-info/licenses/LICENSE,sha256=xrR2ODTGVvR75aaH4il5G4R8JWLKGPYN8jiqCKCvc74,1072
+algorithm_discovery_engine-1.0.0.dist-info/RECORD,,

algorithm_discovery_engine-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

algorithm_discovery_engine-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ade-gui = gui.app:main

algorithm_discovery_engine-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Darshan Kachare
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gui/__init__.py

@@ -0,0 +1,3 @@
+"""Desktop GUI shell for algorithm-discovery-engine (stdlib Tkinter)."""
+
+from gui import core  # noqa: F401