user12953: 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:   

utilize the analysis done on this position last time and look wider at each PLY?   
utilize the analysis done on the upcoming position (after I played 1. e4) and possibly reevaluate 1. e4 based on that?


user12873: 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).

user15223: 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


12953: <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>
 12873: <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>
 15223: <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>
