🔍 Futility pruning

src/Lynx.Cli/appsettings.json

@@ -53,6 +53,10 @@
 
     "SEE_BadCaptureReduction": 2,
 
+    "FP_MaxDepth": 6,
+    "FP_DepthScalingFactor": 60,
+    "FP_Margin": 250,
+
     // Evaluation
     "DoubledPawnPenalty": {
       "MG": -6,

src/Lynx/Configuration.cs

@@ -158,7 +158,7 @@ public sealed class EngineSettings
     [SPSAAttribute<int>(1, 20, 1)]
     public int RFP_MaxDepth { get; set; } = 6;
 
-    [SPSAAttribute<int>(1, 300, 5)]
+    [SPSAAttribute<int>(1, 300, 10)]
     public int RFP_DepthScalingFactor { get; set; } = 107;
 
     [SPSAAttribute<int>(1, 10, 1)]
@@ -192,6 +192,15 @@ public sealed class EngineSettings
     [SPSAAttribute<int>(0, 6, 1)]
     public int SEE_BadCaptureReduction { get; set; } = 2;
 
+    [SPSAAttribute<int>(1, 10, 1)]
+    public int FP_MaxDepth { get; set; } = 6;
+
+    [SPSAAttribute<int>(1, 200, 10)]
+    public int FP_DepthScalingFactor { get; set; } = 60;
+
+    [SPSAAttribute<int>(0, 500, 25)]
+    public int FP_Margin { get; set; } = 250;
+
     #region Evaluation
 
     public TaperedEvaluationTerm DoubledPawnPenalty { get; set; } = new(-6, -12);

src/Lynx/Search/NegaMax.cs

@@ -66,6 +66,7 @@ private int NegaMax(int depth, int ply, int alpha, int beta, bool parentWasNullM
         _searchCancellationTokenSource.Token.ThrowIfCancellationRequested();
 
         bool isInCheck = position.IsInCheck();
+        int staticEval = int.MaxValue, phase = int.MaxValue;
 
         if (isInCheck)
         {
@@ -84,7 +85,7 @@ private int NegaMax(int depth, int ply, int alpha, int beta, bool parentWasNullM
         }
         else if (!pvNode)
         {
-            var (staticEval, phase) = position.StaticEvaluation();
+            (staticEval, phase) = position.StaticEvaluation();
 
             // From smol.cs
             // ttEvaluation can be used as a better positional evaluation:
@@ -102,7 +103,9 @@ private int NegaMax(int depth, int ply, int alpha, int beta, bool parentWasNullM
                 // Return formula by Ciekce, instead of just returning static eval
                 if (staticEval - (Configuration.EngineSettings.RFP_DepthScalingFactor * depth) >= beta)
                 {
+#pragma warning disable S3949 // Calculations should not overflow - value is being set at the beginning of the else if (!pvNode)
                     return (staticEval + beta) / 2;
+#pragma warning restore S3949 // Calculations should not overflow
                 }
 
                 // 🔍 Razoring - Strelka impl (CPW) - https://www.chessprogramming.org/Razoring#Strelka
@@ -249,20 +252,37 @@ private int NegaMax(int depth, int ply, int alpha, int beta, bool parentWasNullM
             }
             else
             {
-                // Late Move Pruning (LMP) - all quiet moves can be pruned
-                // after searching the first few given by the move ordering algorithm
-                if (!pvNode
-                    && !isInCheck
-                    && depth <= Configuration.EngineSettings.LMP_MaxDepth
-                    && scores[moveIndex] < EvaluationConstants.PromotionMoveScoreValue  // Quiet moves
-                    && moveIndex >= Configuration.EngineSettings.LMP_BaseMovesToTry + (Configuration.EngineSettings.LMP_MovesDepthMultiplier * depth)) // Based on formula suggested by Antares
+                if (!pvNode && !isInCheck
+                    && scores[moveIndex] < EvaluationConstants.PromotionMoveScoreValue) // Quiet move
                 {
-                    // After making a move
-                    Game.HalfMovesWithoutCaptureOrPawnMove = oldHalfMovesWithoutCaptureOrPawnMove;
-                    Game.PositionHashHistory.RemoveAt(Game.PositionHashHistory.Count - 1);
-                    position.UnmakeMove(move, gameState);
+                    // Late Move Pruning (LMP) - all quiet moves can be pruned
+                    // after searching the first few given by the move ordering algorithm
+                    if (depth <= Configuration.EngineSettings.LMP_MaxDepth
+                        && moveIndex >= Configuration.EngineSettings.LMP_BaseMovesToTry + (Configuration.EngineSettings.LMP_MovesDepthMultiplier * depth)) // Based on formula suggested by Antares
+                    {
+                        // After making a move
+                        Game.HalfMovesWithoutCaptureOrPawnMove = oldHalfMovesWithoutCaptureOrPawnMove;
+                        Game.PositionHashHistory.RemoveAt(Game.PositionHashHistory.Count - 1);
+                        position.UnmakeMove(move, gameState);
+
+                        break;
+                    }
 
-                    break;
+                    // Futility Pruning (FP) - all quiet moves can be pruned
+                    // once it's considered that they don't have potential to raise alpha
+                    if (movesSearched > 0
+                        //&& alpha < EvaluationConstants.PositiveCheckmateDetectionLimit
+                        //&& beta > EvaluationConstants.NegativeCheckmateDetectionLimit
+                        && depth <= Configuration.EngineSettings.FP_MaxDepth
+                        && staticEval + Configuration.EngineSettings.FP_Margin + (Configuration.EngineSettings.FP_DepthScalingFactor * depth) <= alpha)
+                    {
+                        // After making a move
+                        Game.HalfMovesWithoutCaptureOrPawnMove = oldHalfMovesWithoutCaptureOrPawnMove;
+                        Game.PositionHashHistory.RemoveAt(Game.PositionHashHistory.Count - 1);
+                        position.UnmakeMove(move, gameState);
+
+                        break;
+                    }
                 }
 
                 PrefetchTTEntry();

src/Lynx/UCIHandler.cs

@@ -432,6 +432,30 @@ private void HandleSetOption(ReadOnlySpan<char> command)
                     }
                     break;
                 }
+            case "fp_maxdepth":
+                {
+                    if (length > 4 && int.TryParse(command[commandItems[4]], out var value))
+                    {
+                        Configuration.EngineSettings.FP_MaxDepth = value;
+                    }
+                    break;
+                }
+            case "fp_depthscalingfactor":
+                {
+                    if (length > 4 && int.TryParse(command[commandItems[4]], out var value))
+                    {
+                        Configuration.EngineSettings.FP_DepthScalingFactor = value;
+                    }
+                    break;
+                }
+            case "fp_margin":
+                {
+                    if (length > 4 && int.TryParse(command[commandItems[4]], out var value))
+                    {
+                        Configuration.EngineSettings.FP_Margin = value;
+                    }
+                    break;
+                }
 
             #endregion