Create Generate_sudokuCSV_V2.1.py

Generate_sudokuCSV_V2.1.py

@@ -0,0 +1,180 @@
+
+# Generate_sudokuCSV_V2.1.py
+#
+# Description:
+# This script generates a high-quality, diverse dataset of Sudoku puzzles and their solutions.
+#
+# Key Logic of V2.1:
+# 1.  **Generates Unique Base Solutions:** Uses a randomized backtracking algorithm to
+#     create a set of unique solved grids.
+# 2.  **Intentionally Creates Symmetries:** For each unique base grid, it generates all 8
+#     of its symmetries (rotations and mirrors) and adds them to the dataset.
+# 3.  **Removes ONLY Literal Duplicates:** After generating all grids, it performs a
+#     deduplication step that ONLY removes grids that are 100% identical, block-for-block.
+#     This ensures that rotated and mirrored versions of a grid are KEPT in the final set.
+# 4.  **Creates Puzzles:** A unique puzzle with a different pattern of empty cells is
+#     created for each final, unique grid.
+
+import numpy as np
+import pandas as pd
+import random
+import sys
+import os
+from tqdm import tqdm
+
+class SudokuGeneratorV2_1:
+    """
+    A class to generate a Sudoku dataset that includes symmetric variations
+    but removes only literal duplicates.
+    """
+    def __init__(self, num_base_solutions: int, difficulty: float):
+        if not (0.1 <= difficulty <= 0.99):
+            raise ValueError("Difficulty must be between 0.1 and 0.99")
+            
+        self.num_base_solutions = num_base_solutions
+        self.difficulty = difficulty
+
+    def _find_empty(self, grid):
+        """Finds the next empty cell (value 0) in the grid."""
+        for i in range(9):
+            for j in range(9):
+                if grid[i, j] == 0:
+                    return (i, j)
+        return None
+
+    def _is_valid(self, grid, pos, num):
+        """Checks if placing a number in a position is valid."""
+        row, col = pos
+        # Check row, column, and 3x3 box
+        if num in grid[row, :] or num in grid[:, col]:
+            return False
+        box_x, box_y = col // 3, row // 3
+        if num in grid[box_y*3:box_y*3+3, box_x*3:box_x*3+3]:
+            return False
+        return True
+
+    def _backtrack_solve(self, grid):
+        """A randomized backtracking solver to generate a filled grid."""
+        find = self._find_empty(grid)
+        if not find:
+            return True
+        else:
+            row, col = find
+
+        nums = list(range(1, 10))
+        random.shuffle(nums)
+        for num in nums:
+            if self._is_valid(grid, (row, col), num):
+                grid[row, col] = num
+                if self._backtrack_solve(grid):
+                    return True
+                grid[row, col] = 0
+        return False
+
+    def _get_symmetries(self, grid):
+        """Generates all 8 symmetries of a grid (4 rotations and their mirrors)."""
+        symmetries = []
+        current_grid = grid.copy()
+        for _ in range(4):
+            symmetries.append(current_grid)
+            symmetries.append(np.flipud(current_grid)) # Horizontal mirror
+            current_grid = np.rot90(current_grid)
+        return symmetries
+
+    def _create_puzzle_from_solution(self, solution_grid):
+        """Removes a percentage of cells from a solved grid to create a puzzle."""
+        puzzle = solution_grid.copy().flatten()
+        num_to_remove = int(81 * self.difficulty)
+        indices = list(range(81))
+        random.shuffle(indices)
+        puzzle[indices[:num_to_remove]] = 0
+        return puzzle.reshape((9, 9))
+
+    def generate_and_save(self, output_path: str):
+        """Main orchestrator method."""
+        print("--- Sudoku Generator V2.1 ---")
+        
+        # --- Step 1: Generate unique base solutions ---
+        print(f"Generating {self.num_base_solutions} random base solutions...")
+        base_solutions = []
+        # Use a simple set of strings to avoid generating duplicate bases upfront
+        seen_base_strings = set()
+        with tqdm(total=self.num_base_solutions, desc="Generating Bases") as pbar:
+            while len(base_solutions) < self.num_base_solutions:
+                grid = np.zeros((9, 9), dtype=int)
+                self._backtrack_solve(grid)
+                grid_str = "".join(map(str, grid.flatten()))
+                if grid_str not in seen_base_strings:
+                    seen_base_strings.add(grid_str)
+                    base_solutions.append(grid)
+                    pbar.update(1)
+        
+        # --- Step 2: Expand base solutions with all 8 symmetries ---
+        print("Applying all 8 symmetries to each base solution to create the full candidate set...")
+        all_candidate_solutions = []
+        for grid in tqdm(base_solutions, desc="Applying Symmetries"):
+            all_candidate_solutions.extend(self._get_symmetries(grid))
+        print(f"Generated {len(all_candidate_solutions)} total solutions (including potential literal duplicates).")
+
+        # --- Step 3: Deduplicate ONLY literal, block-for-block duplicates ---
+        print("Removing literal duplicates, keeping all rotations and mirrors...")
+        final_solutions = []
+        seen_literal_strings = set()
+        
+        grid_to_string = lambda g: "".join(map(str, g.flatten()))
+
+        for grid in tqdm(all_candidate_solutions, desc="Deduplicating Literals"):
+            grid_str = grid_to_string(grid)
+            if grid_str not in seen_literal_strings:
+                seen_literal_strings.add(grid_str)
+                final_solutions.append(grid)
+        
+        print(f"Found {len(final_solutions)} unique grids after removing literal duplicates.")
+        print(f"({len(all_candidate_solutions) - len(final_solutions)} literal duplicates were removed).")
+
+        # --- Step 4: Create a puzzle for each unique solution ---
+        print(f"Creating a puzzle for each of the {len(final_solutions)} final grids...")
+        puzzles_and_solutions = []
+        for solution_grid in tqdm(final_solutions, desc="Creating Puzzles"):
+            puzzle_grid = self._create_puzzle_from_solution(solution_grid)
+            puzzles_and_solutions.append({
+                'quizzes': grid_to_string(puzzle_grid),
+                'solutions': grid_to_string(solution_grid)
+            })
+
+        # --- Step 5: Save to CSV ---
+        print(f"\nSaving {len(puzzles_and_solutions)} puzzles to '{output_path}'...")
+        df = pd.DataFrame(puzzles_and_solutions)
+        # Shuffle the final dataset so symmetric puzzles aren't clumped together
+        df = df.sample(frac=1).reset_index(drop=True)
+        df.to_csv(output_path, index=False)
+        
+        print("\n--- Generation Complete ---")
+        print(f"Final dataset contains {len(df)} puzzles.")
+
+
+if __name__ == '__main__':
+    # --- Configuration ---
+    
+    # Number of unique base solutions to generate before applying symmetries.
+    # The final dataset size will be approximately this number * 8.
+    NUM_BASE_SOLUTIONS = 200
+    
+    # The fraction of cells to be empty in the puzzle.
+    DIFFICULTY = 0.7
+    
+    # The output file name.
+    OUTPUT_FILE = 'sudoku.csv'
+
+    # --- Execution ---
+    if os.path.exists(OUTPUT_FILE):
+        overwrite = input(f"WARNING: '{OUTPUT_FILE}' already exists. Overwrite? (y/n): ").lower()
+        if overwrite != 'y':
+            print("Generation cancelled by user.")
+            sys.exit(0)
+            
+    generator = SudokuGeneratorV2_1(
+        num_base_solutions=NUM_BASE_SOLUTIONS,
+        difficulty=DIFFICULTY
+    )
+    generator.generate_and_save(OUTPUT_FILE)