Multiprocessing and Tkinter, summon of Application instead of simple calcul

I have a problem with my code. It's a noughts and crosses project, and I'm creating it in order to learn IA.

I want in the same time to learn about multiprocessing, and I use it to determine if the game is solve or not.

I will put here my code, but to explain, my incomprehension is the fact that my program "recreate" the game when I ask him to just determine a value. And even when I put this part away of my class, He create as much games as the exact number of Pool

Why is not possible to me to just calculate this without this summin of intrusive games ?

import tkinter as Tk
import random as rd
import numpy as np

from multiprocessing import Pool

class Morpion:
    
    def __init__(self):
        
        self.Joueurs = ["Cross", "Circle"]        
        self.Active_Player = self.Joueurs[rd.randint(0,1)]
        self.Victoire = None
        
        # Création de la fenêtre
        
        self.windows = Tk.Tk()
        self.windows.geometry("498x498")
        self.windows.config(bg = "black")
        self.windows.resizable(height = False, width = False)
        
        
        # Création du tableau
        
        self.area = Tk.Canvas()
        self.area.config(bg = "black", height = 494, width = 494)
        self.area.pack()
        
        self.Equivalence = dict()
        
        # On créé les différents espaces qui accueilleront les symboles
        for i in range (3):
            
            for j in range (3):
                
                Espace = self.area.create_rectangle(j * 165, i * 165, 
                                           (j + 1) * 165, (i + 1) * 165,
                                           outline = "white",
                                           fill = "black",
                                           activefill = 'orange'
                                           )
                
                Centre = [(j + 0.5) * 165, (i + 0.5) * 165] 
                 #Centre de la case
                
                Coords_Mat = [i, j]
                # Position dans la matrice
                
                self.Equivalence[Espace] = [Coords_Mat, Centre]
                
                
        # Création de la matrice du jeu
        self.Play_grid = np.zeros(shape=(3,3))

            
    def Play(self):
        
        def Quit(event):
            
            self.windows.destroy()
            
        self.windows.bind('<Escape>', Quit)
        
        
        def Pos_mouse(event):
            
            #On déterminer l'emplacement choisi
            Emplacement = self.Emplacement(event.x, event.y)
            
            #Puis on place le pion
            self.Placer(Emplacement)
            
        self.windows.bind('<Button-1>', Pos_mouse)
        
        
        self.windows.title("Morpion")
        self.windows.focus_force()
        self.windows.mainloop()
        
    
    def Emplacement(self, x : int, y : int) -> int:
        
        # On regarde l'espace sélectionné
        
        Cube = self.area.find_overlapping(x, y, x, y)
        Cube = Cube[0]
        
        return Cube
        
    
    def Placer(self, Emplacement : int):
        
        Data = self.Equivalence[Emplacement]
        
        a,b = Data[0][0], Data[0][1]
        
        if self.Play_grid[a][b] == 0:
        
            x,y = Data[1][0], Data[1][1]
            
            if self.Active_Player == "Circle":
                
                self.Play_grid[a][b] = 1
            
                self.area.create_oval(x - 50, y - 50,
                                     x + 50, y + 50,
                                     
                                     outline = "red",
                                     fill = '',
                                     width = 5)
                
                self.Active_Player = "Cross"
                
            else:
                
                self.Play_grid[a][b] = 2
                
                self.area.create_line(x - 50, y - 50,
                                      x + 50, y + 50,
                                      fill = "blue",
                                      width = 5)
                
                self.area.create_line(x + 50, y - 50,
                                      x - 50, y + 50,
                                      fill = "blue",
                                      width = 5)
                
                self.Active_Player = "Circle"
                
            self.area.itemconfigure(Emplacement, activefill = '')
            
            self.Victoire = self.Detect_Fin()
            
            if self.Victoire != None:
                print(f' C\'est le {self.Victoire} qui a gagné ! ')
                
                self.windows.destroy()

                
                
            
    def Detect_Fin(self):

        
        global Execution_Tests

        def Execution_Tests(Ligne : np.array) -> str:            
                if all(Ligne) == True: #Si pas de 0
                    
                    if sum(Ligne) == 3:
                        return "Joueur cercle"
                    
                    elif sum(Ligne) == 6:
                        return "Joueur croix"
            
        Space = self.Play_grid
        
        if __name__ == '__main__':
            with Pool(2) as p:
                Result = p.map(Execution_Tests, 
                            [Space[0,:], Space[1,:], Space[2,:],
                             Space[:,0], Space[:,1], Space[:,2]])
                
                            # Lignes Horizontales 
                            # Lignes Verticales
                
                print(Result) 
                # On attend une liste de None 
                # Et si le jeu est fini, une itération de Joueur ...
                
        #Diagonale haute
        Ligne = [self.Play_grid[i][i] for i in range (3)]
        if Execution_Tests(Ligne) != None:
            return Execution_Tests(Ligne)
        
        # Diagonale basse
        Ligne = [self.Play_grid[0 + i][2 - i] for i in range (3)] 
        if Execution_Tests(Ligne) != None:
            return Execution_Tests(Ligne)
        
        
        return None
            
            
        
Jeu = Morpion()
Jeu.Play()
🔴 No definitive solution yet