sudoku-smt-solvers 0.1.0__tar.gz

sudoku_smt_solvers-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 liamjdavis
+
+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.

sudoku_smt_solvers-0.1.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.1
+Name: sudoku_smt_solvers
+Version: 0.1.0
+Summary: A collection of SAT and SMT solvers for solving Sudoku puzzles
+Home-page: https://liamjdavis.github.io/sudoku-smt-solvers
+Author: Liam Davis
+Author-email: ljdavis27@amherst.edu
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cvc5
+Requires-Dist: pysat
+Requires-Dist: z3-solver
+
+# Sudoku-SMT-Solvers
+
+[![Pytest + CI/CD](https://github.com/liamjdavis/Sudoku-SMT-Solvers/actions/workflows/test.yml/badge.svg)](ttps://github.com/liamjdavis/Sudoku-SMT-Solvers/actions/workflows/test.yml)
+[![Coverage Status](https://coveralls.io/repos/github/liamjdavis/Sudoku-SMT-Solvers/badge.svg)](https://coveralls.io/github/liamjdavis/Sudoku-SMT-Solvers)
+[![Docs Build Deployment](https://github.com/liamjdavis/Sudoku-SMT-Solvers/actions/workflows/docs.yml/badge.svg)](https://github.com/liamjdavis/Sudoku-SMT-Solvers/actions/workflows/docs.yml)
+[![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://liamjdavis.github.io/sudoku-smt-solvers)
+
+
+## About
+This repository contains the code for the study "Evaluating SMT-Based Solvers on Sudoku". Created by Liam Davis (@liamjdavis) and Ryan Ji (@TairanJ) as their for COSC-241 Artificial Intelligence at Amherst College, it evaluates the efficacy of SMT-Based Solvers by benchmarking three modern SMT solvers (DPLL(T), Z3, and CVC5) against the DPLL algorithm on a collection of 100 25x25 Sudoku puzzles of varying difficulty.
+
+Along with the study, we also published `sudoku-smt-solvers`, a Python package that provides the various SMT-based Sudoku solvers and benchmarking tools we built for this study. The package features DPLL(T), Z3, and CVC5 solvers optimized for 25x25 Sudoku puzzles, a puzzle generator for creating test cases, and a comprehensive benchmarking suite. Available through pip, it offers a simple API for solving Sudoku puzzles using state-of-the-art SMT solvers while facilitating performance comparisons between different solving approaches.
+
+The study aims to answer three research questions: 
+1. How have logical solvers evolved over time in terms of performance and capability?
+2. How do different encodings of Sudoku affect the efficiency and scalability of these solvers?
+3. Are there specific features or optimizations in SMT solvers that provide a significant advantage over traditional SAT solvers for this class of problem?
+
+## Getting started
+### Installation
+To run the code locally, you can install with `pip`
+
+```bash
+pip install sudoku-smt-solvers
+```
+
+### Solvers
+This package includes the DPLL solver and three modern SMT solvers:
+* DPLL(T)
+* CVC5
+* Z3
+
+To run any of the solvers on a 25x25 Sudoku puzzle, you can create an instance of the solver class and call the solve method in a file at the root (Sudoku-smt-solvers). Here is an example using Z3:
+
+```python
+from sudoku_smt_solvers.solvers.z3_solver import Z3Solver
+
+# Example grid (25x25)
+grid = [[0] * 25 for _ in range(25)]
+solver = Z3Solver(grid)
+solution = solver.solve()
+
+if solution:
+    print(f"Solution:\n\n{solution}")
+else:
+    print("No solution exists.")
+```
+
+### Sudoku Generator
+This package also includes a generator for creating Sudoku puzzles to be used as benchmarks. To generate a puzzle, create an instance of the `SudokuGenerator` class and call the `generate` method. Here is an example:
+
+```python
+from sudoku_smt_solvers.benchmarks.sudoku_generator.sudoku_generator import SudokuGenerator
+
+generator = SudokuGenerator(size = 25, givens = 80, timeout = 5, difficulty = "Medium", puzzles_dir = "benchmarks/puzzles", solutions_dir = "benchmarks/solutions")
+
+generator.generate()
+```
+
+Due to the computational complexity of generating large sudoku puzzles, it is recommended that you run multiple generator instances in parallel to create benchmarks.
+
+### Benchmark Runner
+To run the benchmarks you created on all four solvers, create an instance of the `BenchmarkRunner` class and call the `run_benchmarks` method. Here is an example:
+
+```python
+from sudoku_smt_solvers.benchmarks.benchmark_runner import BenchmarkRunner
+
+runner = BenchmarkRunner(
+    puzzles_dir='resources/benchmarks/puzzles/',
+    solutions_dir='resources/benchmarks/solutions/',
+    results_dir='results/'
+)
+runner.run_benchmarks()
+```
+
+## Contributing
+
+We welcome contributions in the form of new solvers, additions to our benchmark suite, or anything that improves the tool! Here's how to get started:
+
+### Development Setup
+
+1. **Fork and Clone**:  
+   Begin by forking the repository and cloning your fork locally:
+   ```bash
+   git clone https://github.com/yourusername/Sudoku-SMT-Solvers.git
+   cd Sudoku-SMT-Solvers
+   ```
+
+2. **Create and Activate a Virtual Environment**:  
+   Set up a Python virtual environment to isolate your dependencies:
+   ```bash
+   python3 -m venv venv
+   source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
+   ```
+
+3. **Install Dependencies**:  
+   Install the required dependencies from the `requirements.txt` file:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Set Up Pre-Commit Hooks**:  
+   Install and configure pre-commit hooks to maintain code quality:
+   ```bash
+   pip install pre-commit
+   pre-commit install
+   ```
+
+   To manually run the hooks and verify code compliance, use:
+   ```bash
+   pre-commit run
+   ```
+
+5. **Testing and Coverage Requirements**:  
+   - Write tests for any new code or modifications.
+   - Use `pytest` for running tests:
+     ```bash
+     pytest
+     ```
+   - Ensure the test coverage is at least 90%:
+
+6. **Add and Commit Your Changes**:  
+   - Follow the existing code style and structure.
+   - Verify that all pre-commit hooks pass and the test coverage meets the minimum requirement.
+   ```bash
+   git add .
+   git commit -m "Description of your changes"
+   ```
+
+7. **Push Your Branch**:
+   Push your changes to your forked repository:
+   ```bash
+   git push origin your-branch-name
+   ```
+
+8. **Open a PR for us to review**
+---
+
+Thank you for your interest in contributing to Sudoku-SMT-Solvers! Your efforts help make this project better for everyone.
+
+
+## Contact Us
+For any questions or support, please reach out to Liam at ljdavis27 at amherst.edu and Ryan at tji26 at amherst.edu

sudoku_smt_solvers-0.1.0/README.md

@@ -0,0 +1,143 @@
+# Sudoku-SMT-Solvers
+
+[![Pytest + CI/CD](https://github.com/liamjdavis/Sudoku-SMT-Solvers/actions/workflows/test.yml/badge.svg)](ttps://github.com/liamjdavis/Sudoku-SMT-Solvers/actions/workflows/test.yml)
+[![Coverage Status](https://coveralls.io/repos/github/liamjdavis/Sudoku-SMT-Solvers/badge.svg)](https://coveralls.io/github/liamjdavis/Sudoku-SMT-Solvers)
+[![Docs Build Deployment](https://github.com/liamjdavis/Sudoku-SMT-Solvers/actions/workflows/docs.yml/badge.svg)](https://github.com/liamjdavis/Sudoku-SMT-Solvers/actions/workflows/docs.yml)
+[![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://liamjdavis.github.io/sudoku-smt-solvers)
+
+
+## About
+This repository contains the code for the study "Evaluating SMT-Based Solvers on Sudoku". Created by Liam Davis (@liamjdavis) and Ryan Ji (@TairanJ) as their for COSC-241 Artificial Intelligence at Amherst College, it evaluates the efficacy of SMT-Based Solvers by benchmarking three modern SMT solvers (DPLL(T), Z3, and CVC5) against the DPLL algorithm on a collection of 100 25x25 Sudoku puzzles of varying difficulty.
+
+Along with the study, we also published `sudoku-smt-solvers`, a Python package that provides the various SMT-based Sudoku solvers and benchmarking tools we built for this study. The package features DPLL(T), Z3, and CVC5 solvers optimized for 25x25 Sudoku puzzles, a puzzle generator for creating test cases, and a comprehensive benchmarking suite. Available through pip, it offers a simple API for solving Sudoku puzzles using state-of-the-art SMT solvers while facilitating performance comparisons between different solving approaches.
+
+The study aims to answer three research questions: 
+1. How have logical solvers evolved over time in terms of performance and capability?
+2. How do different encodings of Sudoku affect the efficiency and scalability of these solvers?
+3. Are there specific features or optimizations in SMT solvers that provide a significant advantage over traditional SAT solvers for this class of problem?
+
+## Getting started
+### Installation
+To run the code locally, you can install with `pip`
+
+```bash
+pip install sudoku-smt-solvers
+```
+
+### Solvers
+This package includes the DPLL solver and three modern SMT solvers:
+* DPLL(T)
+* CVC5
+* Z3
+
+To run any of the solvers on a 25x25 Sudoku puzzle, you can create an instance of the solver class and call the solve method in a file at the root (Sudoku-smt-solvers). Here is an example using Z3:
+
+```python
+from sudoku_smt_solvers.solvers.z3_solver import Z3Solver
+
+# Example grid (25x25)
+grid = [[0] * 25 for _ in range(25)]
+solver = Z3Solver(grid)
+solution = solver.solve()
+
+if solution:
+    print(f"Solution:\n\n{solution}")
+else:
+    print("No solution exists.")
+```
+
+### Sudoku Generator
+This package also includes a generator for creating Sudoku puzzles to be used as benchmarks. To generate a puzzle, create an instance of the `SudokuGenerator` class and call the `generate` method. Here is an example:
+
+```python
+from sudoku_smt_solvers.benchmarks.sudoku_generator.sudoku_generator import SudokuGenerator
+
+generator = SudokuGenerator(size = 25, givens = 80, timeout = 5, difficulty = "Medium", puzzles_dir = "benchmarks/puzzles", solutions_dir = "benchmarks/solutions")
+
+generator.generate()
+```
+
+Due to the computational complexity of generating large sudoku puzzles, it is recommended that you run multiple generator instances in parallel to create benchmarks.
+
+### Benchmark Runner
+To run the benchmarks you created on all four solvers, create an instance of the `BenchmarkRunner` class and call the `run_benchmarks` method. Here is an example:
+
+```python
+from sudoku_smt_solvers.benchmarks.benchmark_runner import BenchmarkRunner
+
+runner = BenchmarkRunner(
+    puzzles_dir='resources/benchmarks/puzzles/',
+    solutions_dir='resources/benchmarks/solutions/',
+    results_dir='results/'
+)
+runner.run_benchmarks()
+```
+
+## Contributing
+
+We welcome contributions in the form of new solvers, additions to our benchmark suite, or anything that improves the tool! Here's how to get started:
+
+### Development Setup
+
+1. **Fork and Clone**:  
+   Begin by forking the repository and cloning your fork locally:
+   ```bash
+   git clone https://github.com/yourusername/Sudoku-SMT-Solvers.git
+   cd Sudoku-SMT-Solvers
+   ```
+
+2. **Create and Activate a Virtual Environment**:  
+   Set up a Python virtual environment to isolate your dependencies:
+   ```bash
+   python3 -m venv venv
+   source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
+   ```
+
+3. **Install Dependencies**:  
+   Install the required dependencies from the `requirements.txt` file:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Set Up Pre-Commit Hooks**:  
+   Install and configure pre-commit hooks to maintain code quality:
+   ```bash
+   pip install pre-commit
+   pre-commit install
+   ```
+
+   To manually run the hooks and verify code compliance, use:
+   ```bash
+   pre-commit run
+   ```
+
+5. **Testing and Coverage Requirements**:  
+   - Write tests for any new code or modifications.
+   - Use `pytest` for running tests:
+     ```bash
+     pytest
+     ```
+   - Ensure the test coverage is at least 90%:
+
+6. **Add and Commit Your Changes**:  
+   - Follow the existing code style and structure.
+   - Verify that all pre-commit hooks pass and the test coverage meets the minimum requirement.
+   ```bash
+   git add .
+   git commit -m "Description of your changes"
+   ```
+
+7. **Push Your Branch**:
+   Push your changes to your forked repository:
+   ```bash
+   git push origin your-branch-name
+   ```
+
+8. **Open a PR for us to review**
+---
+
+Thank you for your interest in contributing to Sudoku-SMT-Solvers! Your efforts help make this project better for everyone.
+
+
+## Contact Us
+For any questions or support, please reach out to Liam at ljdavis27 at amherst.edu and Ryan at tji26 at amherst.edu

sudoku_smt_solvers-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[tool.pre-commit]
+config = ".pre-commit-config.yaml"
+
+[tool.black]
+line-length = 88
+target-version = ["py312"]
+exclude = '''
+/(
+    \.direnv
+    | \.eggs
+    | \.git
+    | \.hg
+    | \.ipynb_checkpoints
+    | \.mypy_cache
+    | \.nox
+    | \.pytest_cache
+    | \.ruff_cache
+    | \.tox
+    | \.env
+    | \.svn
+    | __pypackages__
+    | _build
+    | buck-out
+    | build
+    | dist
+    | venv
+    | sudoku_smt_solvers/solvers/sudoku_error\.py
+    | tests/conftest\.py
+)/
+'''

sudoku_smt_solvers-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sudoku_smt_solvers-0.1.0/setup.py

@@ -0,0 +1,57 @@
+import os
+import setuptools
+import re
+
+NAME = "sudoku_smt_solvers"
+AUTHOR = "Liam Davis"
+AUTHOR_EMAIL = "ljdavis27@amherst.edu"
+DESCRIPTION = "A collection of SAT and SMT solvers for solving Sudoku puzzles"
+LICENSE = "MIT"
+URL = "https://liamjdavis.github.io/sudoku-smt-solvers"
+README = "README.md"
+CLASSIFIERS = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+INSTALL_REQUIRES = [
+    "cvc5",
+    "pysat",
+    "z3-solver",
+]
+ENTRY_POINTS = {}
+SCRIPTS = []
+
+HERE = os.path.dirname(__file__)
+
+
+def read(file):
+    with open(os.path.join(HERE, file), "r") as fh:
+        return fh.read()
+
+
+VERSION = re.search(
+    r'__version__ = [\'"]([^\'"]*)[\'"]', read(NAME.replace("-", "_") + "/__init__.py")
+).group(1)
+LONG_DESCRIPTION = read(README)
+
+
+if __name__ == "__main__":
+    setuptools.setup(
+        name=NAME,
+        version=VERSION,
+        packages=setuptools.find_packages(),
+        author=AUTHOR,
+        author_email=AUTHOR_EMAIL,
+        description=DESCRIPTION,
+        long_description=LONG_DESCRIPTION,
+        long_description_content_type="text/markdown",
+        license=LICENSE,
+        url=URL,
+        classifiers=CLASSIFIERS,
+        install_requires=INSTALL_REQUIRES,
+        entry_points=ENTRY_POINTS,
+        scripts=SCRIPTS,
+        include_package_data=True,
+        python_requires=">=3.9",
+    )

sudoku_smt_solvers-0.1.0/sudoku_smt_solvers/__init__.py

@@ -0,0 +1,4 @@
+from .benchmarks import BenchmarkRunner, SudokuGenerator
+from .solvers import CVC5Solver, DPLLSolver, Z3Solver
+
+__version__ = "0.1.0"

sudoku_smt_solvers-0.1.0/sudoku_smt_solvers/benchmarks/__init__.py

@@ -0,0 +1,5 @@
+from .benchmark_runner import BenchmarkRunner
+from .sudoku_generator.dfs_solver import DFSSolver
+from .sudoku_generator.sudoku_generator import SudokuGenerator
+from .sudoku_generator.las_vegas import LasVegasGenerator
+from .sudoku_generator.hole_digger import HoleDigger

sudoku_smt_solvers-0.1.0/sudoku_smt_solvers/benchmarks/benchmark_runner.py

@@ -0,0 +1,211 @@
+import json
+import os
+import time
+import multiprocessing
+from typing import Dict, List, Optional
+
+from ..solvers import CVC5Solver, DPLLSolver, DPLLTSolver, Z3Solver
+
+
+class BenchmarkRunner:
+    """A benchmark runner for comparing different Sudoku solver implementations.
+
+    This class manages running performance benchmarks across multiple Sudoku solvers,
+    collecting metrics like solve time and propagation counts, and saving results
+    to CSV files.
+
+    Attributes:
+        puzzles_dir (str): Directory containing puzzle JSON files
+        results_dir (str): Directory where benchmark results are saved
+        timeout (int): Maximum time in seconds allowed for each solver attempt
+        solvers (dict): Dictionary mapping solver names to solver classes
+    """
+
+    def __init__(
+        self,
+        puzzles_dir: str = "benchmarks/puzzles",
+        results_dir: str = "benchmarks/results",
+        timeout: int = 120,
+    ):
+        """Initialize the benchmark runner.
+
+        Args:
+            puzzles_dir: Directory containing puzzle JSON files
+            results_dir: Directory where benchmark results will be saved
+            timeout: Maximum time in seconds allowed for each solver attempt
+        """
+        self.puzzles_dir = puzzles_dir
+        self.results_dir = results_dir
+        self.timeout = timeout
+        self.solvers = {
+            "CVC5": CVC5Solver,
+            "DPLL": DPLLSolver,
+            "DPLL(T)": DPLLTSolver,
+            "Z3": Z3Solver,
+        }
+        os.makedirs(results_dir, exist_ok=True)
+
+    def load_puzzle(self, puzzle_id: str) -> Optional[List[List[int]]]:
+        puzzle_path = os.path.join(self.puzzles_dir, f"{puzzle_id}.json")
+        try:
+            with open(puzzle_path, "r") as f:
+                data = json.load(f)
+                for key in ["grid", "puzzle", "gridc"]:
+                    if key in data:
+                        return data[key]
+            print(
+                f"No valid grid found in {puzzle_id}. Available keys: {list(data.keys())}"
+            )
+            return None
+        except Exception as e:
+            print(f"Error loading puzzle {puzzle_id}: {e}")
+            return None
+
+    def _solve_with_timeout(self, solver_class, puzzle, queue):
+        solver = solver_class(puzzle)
+        result = solver.solve()
+        # Pack both the result and propagation count
+        queue.put((result, getattr(solver, "propagated_clauses", 0)))
+
+    def run_solver(self, solver_name: str, puzzle: List[List[int]]) -> Dict:
+        """Run a single solver on a puzzle and collect results with timeout.
+
+        Args:
+            solver_name: Name of the solver to use
+            puzzle: 2D list representing the Sudoku puzzle
+
+        Returns:
+            Dict containing:
+                status: 'sat', 'unsat', 'timeout', or 'error'
+                solve_time: Time taken in seconds
+                propagations: Number of clause propagations (if available)
+        """
+        solver_class = self.solvers[solver_name]
+
+        # Create queue for getting results
+        ctx = multiprocessing.get_context("spawn")
+        queue = ctx.Queue()
+
+        # Create process for solving
+        process = ctx.Process(
+            target=self._solve_with_timeout, args=(solver_class, puzzle, queue)
+        )
+
+        start_time = time.time()
+        process.start()
+        process.join(timeout=self.timeout)
+
+        solve_time = time.time() - start_time
+
+        if process.is_alive():
+            process.terminate()
+            process.join()
+            return {"status": "timeout", "solve_time": self.timeout, "propagations": 0}
+
+        # Get result and propagation count from queue
+        try:
+            result, propagations = queue.get_nowait()
+            return {
+                "status": "sat" if result else "unsat",
+                "solve_time": solve_time,
+                "propagations": propagations,
+            }
+        except:
+            return {"status": "error", "solve_time": solve_time, "propagations": 0}
+
+    def run_benchmarks(self) -> None:
+        """Run all solvers on all puzzles and save results.
+
+        Executes benchmarks for each solver on each puzzle, collecting performance
+        metrics and saving results to a timestamped CSV file.
+
+        The CSV output includes:
+        - Solver name
+        - Puzzle unique ID
+        - Solution status
+        - Solve time
+        - Propagation count
+
+        Also calculates and stores aggregate statistics per solver:
+        - Total puzzles attempted
+        - Number of puzzles solved
+        - Total and average solving times
+        - Total and average propagation counts
+        """
+        results = {
+            solver_name: {
+                "puzzles": {},
+                "stats": {
+                    "total_puzzles": 0,
+                    "solved_count": 0,
+                    "total_time": 0,
+                    "total_propagations": 0,
+                    "avg_time": 0,
+                    "avg_propagations": 0,
+                },
+            }
+            for solver_name in self.solvers
+        }
+
+        puzzle_files = [f for f in os.listdir(self.puzzles_dir) if f.endswith(".json")]
+        print(f"Found {len(puzzle_files)} puzzle files")  # Debug
+
+        for puzzle_file in puzzle_files:
+            puzzle_id = puzzle_file[:-5]
+            puzzle = self.load_puzzle(puzzle_id)
+
+            if not puzzle:
+                print(f"Failed to load puzzle: {puzzle_id}")  # Debug
+                continue
+
+            for solver_name in self.solvers:
+                print(f"Running {solver_name} on puzzle {puzzle_id}")
+                result = self.run_solver(solver_name, puzzle)
+                print(f"Result: {result}")  # Debug
+
+                results[solver_name]["puzzles"][puzzle_id] = result
+
+                stats = results[solver_name]["stats"]
+                stats["total_puzzles"] += 1
+                if result["status"] == "sat":
+                    stats["solved_count"] += 1
+                stats["total_time"] += result["solve_time"]
+                stats["total_propagations"] += result["propagations"]
+
+        # Calculate averages
+        for solver_name, solver_stats in results.items():
+            stats = solver_stats["stats"]
+            total_puzzles = stats["total_puzzles"]
+            if total_puzzles > 0:
+                stats["avg_time"] = stats["total_time"] / total_puzzles
+                stats["avg_propagations"] = stats["total_propagations"] / total_puzzles
+            print(f"Stats for {solver_name}: {stats}")  # Debug
+
+        # Save results
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+
+        # Debug CSV data
+        csv_data = []
+        for solver_name, solver_results in results.items():
+            for puzzle_id, puzzle_result in solver_results["puzzles"].items():
+                row = {
+                    "solver": solver_name,
+                    "puzzle_id": puzzle_id,
+                    "status": puzzle_result["status"],
+                    "solve_time": puzzle_result["solve_time"],
+                    "propagations": puzzle_result["propagations"],
+                }
+                csv_data.append(row)
+                print(f"Adding CSV row: {row}")  # Debug
+
+        csv_path = os.path.join(self.results_dir, f"benchmark_{timestamp}.csv")
+        print(f"Writing {len(csv_data)} rows to CSV")  # Debug
+
+        with open(csv_path, "w") as f:
+            if csv_data:
+                headers = csv_data[0].keys()
+                f.write(",".join(headers) + "\n")
+                for row in csv_data:
+                    f.write(",".join(str(row[h]) for h in headers) + "\n")
+
+        print(f"Benchmark results saved to {csv_path}")

sudoku_smt_solvers-0.1.0/sudoku_smt_solvers/solvers/__init__.py

@@ -0,0 +1,4 @@
+from .cvc5_solver import CVC5Solver
+from .dpll_solver import DPLLSolver
+from .dpllt_solver import DPLLTSolver
+from .z3_solver import Z3Solver