Answers.Body: <p>Yes. This is what hash is: it stores previous analysis.</p>
  
  <blockquote>
    <p>Hash is a database that stores information about positions previously searched, how deeply they were searched, and what was concluded about them. See also <a href="https://www.chessprogramming.org/Hash_Table" rel="nofollow noreferrer">https://www.chessprogramming.org/Hash_Table</a></p>
  </blockquote>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2018-12-30T00:29:02.110Z
Answers.Text: To nitpick: a hash is only the _index_ of a position within such a database. The database as a whole is a hash _table_. And anyway: even if a hash table is used, doesn't necessarily mean the engine will keep it between the actual moves. It is still useful even if you only use it to omit transpositions in the analysis of a single move.
Answers.UserDisplayName: leftaroundabout
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2018-12-30T01:33:50.267Z
Answers.Text: Well, I took that quote from the TCEC twitch chat !hash command, so let them know if it's incorrect :D
Answers.UserDisplayName: Allure
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2018-12-29T21:56:20.670Z
Answers.LastActivityDate: 2018-12-29T21:56:20.670Z
Answers.UserDisplayName: Allure
Answers.Body: <p>I can't speak for all game playing engines, but a good engine would indeed remember past analysis. Having a "first-draft" evaluation of a position (and all the positions that can arise from each move) allows the engine to do move-ordering. This is where it looks at all possible moves in the order of "probable best" to "probable worst", based off the aforementioned "first-draft" evaluations that it saves.</p>
  
  <p>By looking at the subtrees of moves that are probably better first, the engine is able to perform the minimax + alpha-beta algorithms MUCH more efficiently. Already looking at a good move/subtree allows you to prune a bad move/subtree, but not vice versa.</p>
  
  <p>High quality engines actually perform their search via iterative-deepening. Search one move ahead, then go back to the starting position. Search two moves ahead, then go back to the starting position. All the way up to N moves ahead. That might seem inefficient, but it shows how powerful having some preliminary knowledge of a position and its moves can be before expanding further on it.</p>
  
  <p>For your specific question, I assume you mean when you go forward and backwards <em>manually</em> in ChessBase. In this case I'm not sure if the engine remembers everything it calculates, because that's a lot of data to store just for the specific case of the user clicking back to a previous position. It seems pretty space inefficient. I tested it on ChessBase by making a move and seeing how fast the engine's depth climbed. Getting to depth 20 was slightly faster on the second time than the first time, but it wasn't instantaneous on the second time (which it should be if it did remember all its calculations the first time I manually brought it to the position).</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2018-12-29T22:26:56.657Z
Answers.LastActivityDate: 2018-12-29T22:26:56.657Z
Answers.UserDisplayName: Inertial Ignorance
Body: <p>Suppose I let the engine analyze a given position (let's say for simplicity the starting position), and then I execute the move suggested by the engine (let's say 1. e4). Then I let the engine analyze the upcoming position (black to move after 1. e4), and after a while I take the move back and let the engine again analyze the original position (the starting position, white to move again), will it:   </p>
  
  <ol>
  <li>utilize the analysis done on this position last time and look wider at each PLY?   </li>
  <li>utilize the analysis done on the upcoming position (after I played 1. e4) and possibly reevaluate 1. e4 based on that?</li>
  </ol>
  
Tags: <engines>
Title: Do engines remember previous analysis?
ThreadText: # Do engines remember previous analysis?
  
  (Asked by: username_0 on 2018-12-29)
  
  Suppose I let the engine analyze a given position (let's say for simplicity the starting position), and then I execute the move suggested by the engine (let's say 1. e4). Then I let the engine analyze the upcoming position (black to move after 1. e4), and after a while I take the move back and let the engine again analyze the original position (the starting position, white to move again), will it:
  
  1. utilize the analysis done on this position last time and look wider at each PLY?
  2. utilize the analysis done on the upcoming position (after I played 1. e4) and possibly reevaluate 1. e4 based on that?
  
  **Tags:** engines
  
  
  ---
  
  ## 2 answers
  
  ### Answer by username_1 on 2018-12-29. Score: 4
  
  Yes. This is what hash is: it stores previous analysis.
  
  > Hash is a database that stores information about positions previously searched, how deeply they were searched, and what was concluded about them. See also <https://www.chessprogramming.org/Hash_Table>
  
  > **Comments:**
  > **username_2**: To nitpick: a hash is only the _index_ of a position within such a database. The database as a whole is a hash _table_. And anyway: even if a hash table is used, doesn't necessarily mean the engine will keep it between the actual moves. It is still useful even if you only use it to omit transpositions in the analysis of a single move.  
  > **username_1**: Well, I took that quote from the TCEC twitch chat !hash command, so let them know if it's incorrect :D  
  
  ---
  
  ### Answer by username_3 on 2018-12-29. Score: 3
  
  I can't speak for all game playing engines, but a good engine would indeed remember past analysis. Having a "first-draft" evaluation of a position (and all the positions that can arise from each move) allows the engine to do move-ordering. This is where it looks at all possible moves in the order of "probable best" to "probable worst", based off the aforementioned "first-draft" evaluations that it saves.
  
  By looking at the subtrees of moves that are probably better first, the engine is able to perform the minimax + alpha-beta algorithms MUCH more efficiently. Already looking at a good move/subtree allows you to prune a bad move/subtree, but not vice versa.
  
  High quality engines actually perform their search via iterative-deepening. Search one move ahead, then go back to the starting position. Search two moves ahead, then go back to the starting position. All the way up to N moves ahead. That might seem inefficient, but it shows how powerful having some preliminary knowledge of a position and its moves can be before expanding further on it.
  
  For your specific question, I assume you mean when you go forward and backwards *manually* in ChessBase. In this case I'm not sure if the engine remembers everything it calculates, because that's a lot of data to store just for the specific case of the user clicking back to a previous position. It seems pretty space inefficient. I tested it on ChessBase by making a move and seeing how fast the engine's depth climbed. Getting to depth 20 was slightly faster on the second time than the first time, but it wasn't instantaneous on the second time (which it should be if it did remember all its calculations the first time I manually brought it to the position).
  
  
  ---
  
  