Create sudokuCSV_analyzer_v2.py

sudokuCSV_analyzer_v2.py

@@ -0,0 +1,197 @@
+# sudokuCSV_analyzer_v2.py
+#
+# Description:
+# This script analyzes a 'sudoku.csv' file to identify duplicate and symmetric puzzles
+# by comparing the FULLY SOLVED grids from the 'solutions' column.
+#
+# Main Functions:
+# 1. Finds and logs pairs of solved grids that are exact duplicates.
+# 2. Finds and logs pairs of solved grids that are rotations or mirrors of each other.
+# 3. Generates histograms for two similarity metrics based on the solved grids.
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from tqdm.auto import tqdm
+import os
+
+# === HELPER FUNCTIONS =======================================================
+
+def string_to_grid(s: str) -> np.ndarray:
+    """Converts an 81-character string to a 9x9 NumPy array."""
+    return np.array(list(map(int, s))).reshape((9, 9))
+
+def grid_to_string(g: np.ndarray) -> str:
+    """Converts a 9x9 NumPy array back to an 81-character string."""
+    return "".join(map(str, g.flatten()))
+
+def get_all_symmetries(grid: np.ndarray) -> set:
+    """
+    Generates all 8 unique symmetries (rotations and mirrors) for a given grid.
+    Returns a set of the grids represented as strings.
+    """
+    symmetries = set()
+    current_grid = grid.copy()
+    
+    for _ in range(4):  # 4 rotations
+        symmetries.add(grid_to_string(current_grid))
+        symmetries.add(grid_to_string(np.flipud(current_grid))) # Horizontal mirror
+        current_grid = np.rot90(current_grid)
+        
+    return symmetries
+
+def compare_cell_similarity(grid1: np.ndarray, grid2: np.ndarray) -> int:
+    """Counts the number of cells that have the same value in the same position."""
+    return np.sum(grid1 == grid2)
+
+def compare_digit_frequency_similarity(grid1: np.ndarray, grid2: np.ndarray) -> int:
+    """
+    Counts how many digits (1-9) have the same frequency in both grids.
+    """
+    # Since we are using solved grids, there are no zeros to filter.
+    # The logic remains robust if ever used with unsolved puzzles.
+    vals1, counts1 = np.unique(grid1, return_counts=True)
+    vals2, counts2 = np.unique(grid2, return_counts=True)
+    
+    freq_map1 = dict(zip(vals1, counts1))
+    freq_map2 = dict(zip(vals2, counts2))
+    
+    similar_freq_count = 0
+    for digit in range(1, 10):
+        if freq_map1.get(digit, 0) == freq_map2.get(digit, 0):
+            similar_freq_count += 1
+            
+    return similar_freq_count
+
+# === MAIN ANALYSIS FUNCTION =================================================
+
+def analyze_solved_grids(
+    csv_path: str = 'sudoku.csv',
+    start_index: int = 0,
+    end_index: int = 600,
+    min_diff_cells_for_log: int = 4
+):
+    """
+    Main function to drive the analysis of the solved sudoku grids.
+    """
+    print("--- Sudoku Solved Grid Analyzer ---")
+
+    # 1. Load Data
+    if not os.path.exists(csv_path):
+        print(f"ERROR: The file '{csv_path}' was not found.")
+        print("Please ensure the sudoku data file is in the same directory.")
+        return
+
+    print(f"Loading data from '{csv_path}'...")
+    df = pd.read_csv(csv_path)
+    
+    if 'solutions' not in df.columns:
+        print("ERROR: The CSV file must contain a 'solutions' column with fully solved grids.")
+        return
+        
+    # Ensure the range is valid
+    if end_index > len(df):
+        print(f"Warning: end_index ({end_index}) is greater than number of puzzles ({len(df)}). Adjusting to max.")
+        end_index = len(df)
+    if start_index >= end_index:
+        print("Error: start_index must be less than end_index.")
+        return
+
+    # *** KEY CHANGE IS HERE: Use the 'solutions' column ***
+    print("Analyzing the 'solutions' column (fully solved grids).")
+    puzzle_solutions = df['solutions'].iloc[start_index:end_index].tolist()
+    grids = [string_to_grid(p) for p in puzzle_solutions]
+    num_grids = len(grids)
+    print(f"Analysis will be performed on {num_grids} solved grids (indices {start_index} to {end_index-1}).")
+
+    # 2. Prepare data structures for results
+    exact_duplicates = []
+    symmetry_pairs = []
+    cell_similarity_counts = []
+    digit_freq_similarity_counts = []
+
+    print("\nStarting pairwise comparison... This may take a while.")
+    
+    # 3. Perform pairwise comparison
+    for i in tqdm(range(num_grids), desc="Analyzing Solved Grids"):
+        grid_i = grids[i]
+        symmetries_of_i = get_all_symmetries(grid_i)
+        
+        for j in range(i + 1, num_grids):
+            grid_j = grids[j]
+            
+            if np.array_equal(grid_i, grid_j):
+                exact_duplicates.append({'index_1': start_index + i, 'index_2': start_index + j})
+                continue
+            
+            if grid_to_string(grid_j) in symmetries_of_i:
+                symmetry_pairs.append({'index_1': start_index + i, 'index_2': start_index + j})
+                
+            num_same_cells = compare_cell_similarity(grid_i, grid_j)
+            
+            if (81 - num_same_cells) >= min_diff_cells_for_log:
+                 cell_similarity_counts.append(num_same_cells)
+                 digit_freq_similarity_counts.append(compare_digit_frequency_similarity(grid_i, grid_j))
+
+    print("\nAnalysis complete. Saving results...")
+
+    # 4. Save results to CSV files
+    if exact_duplicates:
+        duplicates_df = pd.DataFrame(exact_duplicates)
+        duplicates_df.to_csv('solved_exact_duplicates.csv', index=False)
+        print(f"Found {len(duplicates_df)} exact duplicate pairs. Logged to 'solved_exact_duplicates.csv'.")
+    else:
+        print("No exact duplicates found in the specified range.")
+
+    if symmetry_pairs:
+        symmetry_df = pd.DataFrame(symmetry_pairs)
+        symmetry_df.to_csv('solved_possible_symmetry_pairs.csv', index=False)
+        print(f"Found {len(symmetry_df)} potential symmetry pairs. Logged to 'solved_possible_symmetry_pairs.csv'.")
+    else:
+        print("No symmetry pairs found in the specified range.")
+        
+    # 5. Generate and save histograms
+    sns.set_style("darkgrid")
+
+    # Histogram 1: Cell Similarity
+    plt.figure(figsize=(12, 6))
+    sns.histplot(cell_similarity_counts, bins=81, kde=False)
+    plt.title(f'Distribution of Cell Similarity on Solved Grids ({num_grids} Grids)', fontsize=16)
+    plt.xlabel('Number of Identical Cells in Same Position (out of 81)', fontsize=12)
+    plt.ylabel('Frequency (Number of Pairs)', fontsize=12)
+    plt.xlim(0, 81)
+    plt.tight_layout()
+    plt.savefig('solved_cell_similarity_histogram.png')
+    plt.close()
+    print("Saved 'solved_cell_similarity_histogram.png'.")
+
+    # Histogram 2: Digit Frequency Similarity
+    plt.figure(figsize=(12, 6))
+    sns.histplot(digit_freq_similarity_counts, bins=10, discrete=True, kde=False)
+    plt.title(f'Distribution of Digit Frequency Similarity on Solved Grids ({num_grids} Grids)', fontsize=16)
+    plt.xlabel('Number of Digits (1-9) with Same Frequency in Both Grids', fontsize=12)
+    plt.ylabel('Frequency (Number of Pairs)', fontsize=12)
+    plt.xticks(range(10))
+    plt.tight_layout()
+    plt.savefig('solved_digit_frequency_similarity_histogram.png')
+    plt.close()
+    print("Saved 'solved_digit_frequency_similarity_histogram.png'.")
+    
+    print("\n--- Analysis Finished ---")
+
+
+if __name__ == '__main__':
+    # --- Configuration ---
+    DATA_FILE_PATH = 'sudoku.csv'
+    START_PUZZLE_INDEX = 0
+    END_PUZZLE_INDEX = 600
+    MIN_DIFFERENT_CELLS = 4
+    
+    # --- Execution ---
+    analyze_solved_grids(
+        csv_path=DATA_FILE_PATH,
+        start_index=START_PUZZLE_INDEX,
+        end_index=END_PUZZLE_INDEX,
+        min_diff_cells_for_log=MIN_DIFFERENT_CELLS
+    )