Graphs as methods of implication

Graph theory, like matrix games, are fundamental concepts in programming and data structures. Databases rely on mathematical objects for logical connection in their methods of storing and working with data.

def print_tree_by_level(tree):
    for level in tree:
        print(level)

def print_tree_by_level2(tree):
    for level in tree:
        for i in range(len(level)):
            print(str(level[i]), end = ' ')
        print()

def get_path(edge):
    path = []
    while edge.parent:
        path.append(edge.tag)
        edge = edge.parent
    path.append(edge.tag)
    return path[::-1]

1. Implication is used when we indicate the structure and methods of working with it for a certain consequence, i.e. result (e.g. graph data and the function of adding a vertex lead to the expansion of the playing field in the matrix)
2. There are 3 basic actions with a vertex: adding, sorting, deleting. Deeper implementation goes through the base
3. The merging of processed vertices into a tree occurs through cycles. It's important to keep track of the order of the vertices in the layer

Separate math methods into functions to encapsulate and call them quickly for each layer, in a loop:

tree = generate_random_game_tree(g_cur_game)
solution = reverse_induction(tree, g_cur_game)
path = get_path(solution.path_last)
print("Game cost array: {}".format(solution.cost_array))
print("Winner is {} player ({})".format(1 + get_max_index(solution.cost_array), max(solution.cost_array)))
print("Path is {}".format(path))

We also print output cyclically, layer by layer. Alignment of vertices by constant lengths is mandatory. Without an output format that is understandable to the user, it is impossible to test yourself.