Support filtering based on PV (#39)

Filter by material and uniqueness of PV

Author: ianfab

docs/generate_puzzles.md

@@ -32,10 +32,16 @@ Currently the following options are available:
 
 `material_limit` - maximum allowed material advantage. Positions with material imbalance exceeding this value are filtered out. Default: 64000 (effectively disabled).
 
+`final_material_limit` - maximum allowed material imbalance after playing the validation PV. Helps avoid puzzles where the mating line ends with overwhelming extra material. Default: 64000 (effectively disabled).
+
+`material_diff_limit` - maximum allowed absolute change in material imbalance between the candidate position and the final position reached by the validation PV. Default: 64000 (effectively disabled).
+
 `mate_ply` - only keep positions with mate in at least this many plies. Filters out mates that are too short. When using `puzzle_depth` it applies to this validation search, otherwise uses the regular search result. Default: 1.
 
 `second_pv_limit` - uses multipv 2 during puzzle verification and filters out positions where the second best line's evaluation is greater than or equal to this value (in centipawns). This helps ensure puzzle positions have a clear best solution by filtering out positions with strong alternative moves. Set to a value >= 32000 (VALUE_MATE) to disable this check. Default: 1000.
 
+`second_pv_nonroot_limit` - when validating the PV recursively, re-search positions where the attacking side is to move again. If the second-best move at any of those points evaluates above this limit, the puzzle is rejected. The search depth shrinks as the PV progresses. Set to a value >= 32000 (VALUE_MATE) to disable. Default: VALUE_MATE_IN_MAX_PLY.
+
 `random_move_min_ply` - the minimal ply at which a random move may be executed instead of a move chosen by search. Default: 1.
 
 `random_move_max_ply` - the maximal ply at which a random move may be executed instead of a move chosen by search. Default: 150.

src/tools/puzzle_generator.cpp

@@ -56,8 +56,11 @@ namespace Stockfish::Tools
             // Upper limit of evaluation value of generated situation
             int king_safety_limit = 64000;
             int material_limit = 64000;
+            int final_material_limit = 64000;
+            int material_diff_limit = 64000;
             int mate_ply = 1;
             int second_pv_limit = 1000;
+            int second_pv_nonroot_limit = VALUE_MATE_IN_MAX_PLY;
 
             // minimum ply with random move
             // maximum ply with random move
@@ -358,6 +361,61 @@ namespace Stockfish::Tools
                                     keep = false;
                             }
                         }
+
+                        const bool check_material_limits = params.final_material_limit < 64000
+                            || params.material_diff_limit < 64000;
+                        const bool check_recursive_uniqueness = params.second_pv_nonroot_limit < VALUE_MATE;
+
+                        if (keep
+                            && !search_pv2.empty()
+                            && (check_material_limits || check_recursive_uniqueness))
+                        {
+                            const Color initial_side = pos.side_to_move();
+                            const auto material_balance = [initial_side](const Position& position) {
+                                return mg_value(initial_side == WHITE ? position.psq_score()
+                                                                      : -position.psq_score());
+                            };
+
+                            const Value initial_material = material_balance(pos);
+
+                            std::vector<StateInfo, AlignedAllocator<StateInfo>> validation_states(search_pv2.size());
+                            size_t executed = 0;
+
+                            for (Move pv_move : search_pv2)
+                            {
+                                if (!is_ok(pv_move))
+                                    break;
+
+                                pos.do_move(pv_move, validation_states[executed]);
+                                ++executed;
+                            }
+
+                            Value final_material = material_balance(pos);
+                            Value material_delta = final_material - initial_material;
+
+                            if (   final_material > params.final_material_limit
+                                || material_delta > params.material_diff_limit)
+                                keep = false;
+
+                            while (executed > 0)
+                            {
+                                if (keep
+                                    && check_recursive_uniqueness
+                                    && pos.side_to_move() == initial_side)
+                                {
+                                    int depth_remaining = std::max(1, params.puzzle_depth - static_cast<int>(executed) / 2);
+                                    auto [nested_value, nested_pv] = Search::search(pos, depth_remaining, 2, 0);
+                                    auto& nested_rm = pos.this_thread()->rootMoves;
+                                    if (nested_rm.size() >= 2)
+                                    {
+                                        Value second_value = nested_rm[1].score;
+                                        if (second_value >= params.second_pv_nonroot_limit)
+                                            keep = false;
+                                    }
+                                }
+                                pos.undo_move(search_pv2[--executed]);
+                            }
+                        }
                     }
 
                     // As a fallback if puzzle_depth is not set
@@ -653,7 +711,7 @@ namespace Stockfish::Tools
             sfen_writer.write(th.id(), sfen);
         }
 
-        return false;
+        return counter.load(std::memory_order_relaxed) >= limit;
     }
 
     void PuzzleGenerator::report(uint64_t done, uint64_t draws, uint64_t new_done)
@@ -738,10 +796,16 @@ namespace Stockfish::Tools
                 is >> params.king_safety_limit;
             else if (token == "material_limit")
                 is >> params.material_limit;
+            else if (token == "final_material_limit")
+                is >> params.final_material_limit;
+            else if (token == "material_diff_limit")
+                is >> params.material_diff_limit;
             else if (token == "mate_ply")
                 is >> params.mate_ply;
             else if (token == "second_pv_limit")
                 is >> params.second_pv_limit;
+            else if (token == "second_pv_nonroot_limit")
+                is >> params.second_pv_nonroot_limit;
             else if (token == "random_move_min_ply")
                 is >> params.random_move_minply;
             else if (token == "random_move_max_ply")
@@ -839,8 +903,11 @@ namespace Stockfish::Tools
             << "  - count                  = " << loop_max << endl
             << "  - king_safety_limit      = " << params.king_safety_limit << endl
             << "  - material_limit         = " << params.material_limit << endl
+            << "  - final_material_limit   = " << params.final_material_limit << endl
+            << "  - material_diff_limit    = " << params.material_diff_limit << endl
             << "  - mate_ply               = " << params.mate_ply << endl
             << "  - second_pv_limit        = " << params.second_pv_limit << endl
+            << "  - second_pv_nonroot_limit = " << params.second_pv_nonroot_limit << endl
             << "  - num threads (UCI)      = " << params.num_threads << endl
             << "  - random_move_min_ply    = " << params.random_move_minply << endl
             << "  - random_move_max_ply    = " << params.random_move_maxply << endl