Minimax (with alpha beta pruning): when to store the solution? - minimax

Question

I have implemented a version of the minimax algorithm with alpha/beta pruning, for a connect four game. When using minimax, I would like to save the best AI column to play for in a dictionary called solution (so that, I can also save other information if needed).
So my pseudo code looks like this:
function alphabeta(node, depth, α, β, maximizingPlayer, solution) is
if depth = 0 or node is a terminal node then
return the heuristic value of node
value = None
if maximizingPlayer then # AI is playing
value := −∞
for each child of node do
value_new := alphabeta(child, depth − 1, α, β, FALSE)
if value_new > value then
value = value_new
solution.update({'best_column': child_node_move})
if value ≥ β then
break (* β cutoff *)
α := max(α, value)
else
value := +∞
for each child of node do
value := min(value, alphabeta(child, depth − 1, α, β, TRUE))
if value ≤ α then
break (* α cutoff *)
β := min(β, value)
return value
where child_node_move is a move being tested from a new child node (e.g. each child node is a connect four state, with a move being tested for best move).
Now, I have noticed that the algorithm doesn't quite work when I store values in solution and I don't filter on the depth. Indeed, the algorithm will work at depth 1 but not when I increase the depth parameter.
The only way I managed the algorithm to work, is by modifying the update of solution only when the depth is at 0. For example, If the initial depth is four, I replace part of the above code with:
if value_new > value then
value = value_new
if depth == 4: # only store for the root level => this works
solution.update({'best_column': child_node_move})
So my question is two-fold:
Am I supposed to store the solution only at the root level? If so, why? I don't really understand why this is working actually, and not the other way around.
Should I also store solutions when the MIN player is playing? To me it makes no sense. Also, what is the MIN player minimizing? His own score, or the MAX score?
Edit: here is my code
def minimax(self, board: np.ndarray, depth: int, alpha: float, beta: float, is_max_player: bool, solution) -> float:
assert alpha < beta
sy, sx = board.shape
# When the depth limit of the search is exceeded,
# score the node as if it were a leaf
# The heuristic value is a score measuring the favorability of the node for the maximizing player.
if depth == 0 or self.is_last_move(board) or self.is_winning_move(board):
return self.score(board)
if is_max_player:
value = -np.inf
for k in range(0, sx):
if 0 in board[:, k]:
b = ConnectN.play(board, k, True)
value_new = self.minimax(b, depth - 1, alpha, beta, (not is_max_player), solution)
if value_new > value: # maximize value
value = value_new
solution.update({'col': k, 'depth': depth, 'score': value,'is_max_player': is_max_player})
if value >= beta: # beta pruning
break
alpha = max(alpha, value) # no fail-soft
else:
value = np.inf
for k in range(0, sx):
if 0 in board[:, k]:
b = ConnectN.play(board, k, False)
value_new = self.minimax(b, depth - 1, alpha, beta, (not is_max_player), solution)
if value_new < value: # minimize value
value = value_new
# solution.update({'col': k, 'depth': depth, 'score': value,'is_max_player': is_max_player})
if value <= alpha: # alpha pruning
break
beta = min(beta, value) # no fail-soft
return value
board is a numpy.ndarray with shape (sy=6, sx=7). Function is called like this:
solution = {}
score = self.minimax(c4, 4, alpha=-np.inf, beta=+np.inf, is_max_player=True, solution=solution)
best_move = solution['col']
The score function is pretty basic (pseudo code):
initial score = 0
for every sets of four slots (horizontal, vertical, both diagonals)
do
if AI connects four chessmen: score = Infinity
elif AI connects three chessmen and one empty slot: score += 300
elif AI connects two chessmen and two empty slots: score += 200
if HUMAN connects three chessmen and one empty slot: score -=500
if HUMAN connects four chessmen: score = -Infinity
return score