from itertools import *

n = 3

probs_matrix = [[0 for _ in range(n)] for _ in range(n)]
gi = [0]

def set_to_str(set):
    set = [str(x) for x in set]
    return ''.join(sorted(set))

def sets_to_str(s1, s2, s3):
    return "{},{},{}".format(set_to_str(s1), set_to_str(s2), set_to_str(s3))

def subsets(set, count):
    return list(combinations(set, count))

def val_from_matrix(matrix):
    x_len = len(matrix)
    y_len = x_len
    if len(matrix) == 0 or len(matrix[0]) == 0:
        return 0
    p = MixedIntegerLinearProgram()
    v = p.new_variable()
    x = p.new_variable()
    p.set_objective(v[0])
    p.add_constraint(sum(x[i] for i in range(x_len)) == 1)
    for i in range(x_len):
        p.add_constraint(x[i] >= 0)

    for i in range(x_len):
        p.add_constraint(sum(matrix[j][i] * x[j] for j in range(y_len)) - v[0] >= 0)
    p.solve()
    ret = p.get_values(v[0])
    if x_len == n:
        for i in range(n):
            probs_matrix[i][gi[0]] = p.get_values(x[i])
        gi[0] = gi[0] + 1
    return ret


def get_val_from_dict(V, Y, P):
    str_sets = sets_to_str(V, Y, P)
    if sorted(V) == sorted(Y):
        ret = 0
    elif dict.get(str_sets) is None:
        ret = -1 * dict[sets_to_str(Y, V, P)]
    else:
        ret = dict[str_sets]
    return ret

def sublist(list, index):
    return list[:index] + list[index + 1:]

def create_row(V, Y, P, k, index):
    row = []
    for i in range(len(Y)):
        row.append(P[k] * 1.0 * sign(V[index] - Y[i]) + get_val_from_dict(sublist(V, index), sublist(Y, i), sublist(P, k)))
    return row

def create_matrix(V, Y, P, k):
    mat = []
    for i in range(len(V)):
        mat.append(create_row(V, Y, P, k, i))
    if len(mat) == n:
        show('V=', V, ', Y=', Y, ', P=', P, ', Card ' , P[k],'played, matrix: ', matrix(RR, mat))
    return mat

dict = {",,": 0}

def compute(n, step):
    subs = subsets(range(1, n + 1), step)
    for i in range(len(subs)):
        for j in range(i + 1):
            for k in range(len(subs)):
                V = subs[i]
                Y = subs[j]
                P = subs[k]
                dict[sets_to_str(V, Y, P)] = (1.0/len(P)) * sum(val_from_matrix(create_matrix(V, Y, P, kj)) for kj in range(len(P)))

def finish(n):
    for i in range(1, n + 1):
        compute(n, i)

finish(n)
show('Probability Matrix: ', matrix(RR, probs_matrix))