import collections
import itertools
from os import replace
import re
import json

def solveLogic(logic, symbol, logicFunc):
    regComp = re.compile("(?P<expression>(?P<oper1>[a,p])(?P<op>\{})(?P<oper2>[a,p]))".format(symbol))
    
    while True:
        res = regComp.search(logic)
        if not res:
            break
        resAr = res.groups()
        oper1 = resAr[1] == "p"
        oper2 = resAr[3] == "p"
        endRes = logicFunc(oper1, oper2)
        charRes = "p" if endRes else "a"
        logic = logic.replace(resAr[0], charRes)
    return logic    
    

def getTruth(logic):
    logic = logic.strip()
    braceCoors = []
    currStart = -1
    braceCount = 0
    for i in range(0, len(logic)):
        character = logic[i]
        if character=="(":
            if braceCount==0:
                currStart = i
            braceCount+=1
        if character==")":
            braceCount-=1
            if braceCount==0:
                braceCoors.append(
                    {
                        "withBraces" : logic[currStart:i+1],
                        "withoutBraces" : logic[(currStart+1):i]
                    })
    for coor in braceCoors:
        logic = logic.replace(coor["withBraces"], getTruth(coor["withoutBraces"]))                  


    logic = logic.replace("-", "")
    logic = logic.replace("!a", "p")
    logic = logic.replace("!p", "a")
    logic = solveLogic(logic, "&", lambda oper1, oper2 : oper1 and oper2)
    logic = solveLogic(logic, "|", lambda oper1, oper2 : oper1 or oper2)
    logic = solveLogic(logic, "^", lambda oper1, oper2 : oper1 ^ oper2)
    logic = solveLogic(logic, ">", lambda oper1, oper2 : not oper1 or oper2)
    logic = solveLogic(logic, "=", lambda oper1, oper2 : oper1 == oper2)                     
    return logic

def getInputs(varCount):
    inputs = []
    for combination in itertools.product(['a', 'p'], repeat=varCount):
        combStr = ''.join(combination)
        inputs.append((input(combStr + ": "), combination)) # piem. app: 
    return inputs

def getGenericVars(count):
    vars = []
    for i in range(count):
        vars.append(chr(ord('A')+i))
    return vars

def getCon(vals, varList):
    if all(val[0] == 'a' for val in vals):
        return 'a'
    resSets = []
    for val in vals:
        if val[0] == 'p':
            currResSet = []
            for i in range(len(val[1])):
                toAppend  = varList[i]
                if val[1][i] == 'a':
                    toAppend = '!' + toAppend
                currResSet.append(toAppend) 
            resSets.append('('+'&'.join(currResSet) + ')')    
    return '|'.join(resSets)     

def getDis(vals, varList):
    if all(val[0] == 'p' for val in vals):
        return 'p'
    resSets = []
    for val in vals:
        if val[0] == 'a':
            currResSet = []
            for i in range(len(val[1])):
                toAppend  = varList[i]
                if val[1][i] == 'p':
                    toAppend = '!' + toAppend
                currResSet.append(toAppend)
            resSets.append('(' + '|'.join(currResSet) + ')')    
    return '&'.join(resSets)        

def getVariations(expression):
    vars = dict()
    variations = []
    pattern = re.compile("!|&|-|>|\(|\)|\||=| |a|p|\^")
    for char in expression:
        if not pattern.match(char):
            vars[char] = char
    variations = itertools.product(['a', 'p'], repeat = len(vars))
    return {
        "vars" : list(vars.values()),
        "variations" : variations
    }

def findConFromExpr(expr):
    variations = getVariations(expr)
    valueTable = []
    for variation in variations["variations"]:
        logic = expr
        for i in range(len(variations["vars"])):
            var = variations["vars"][i]
            logic = logic.replace(var, variation[i])
        valueTable.append((getTruth(logic), variation))
    return getCon(valueTable, variations["vars"])

def findDisFromExpr(expr):
    variations = getVariations(expr)
    valueTable = []
    for variation in variations["variations"]:
        logic = expr
        for i in range(len(variations["vars"])):
            var = variations["vars"][i]
            logic = logic.replace(var, variation[i])
        valueTable.append((getTruth(logic), variation))
    return getDis(valueTable, variations["vars"])

while True:

    operationType = input("Izvēlaties atrisināt loģisko izteiksmi(1) vai iegūt normālformu no tabulas rezultātiem(2), izteiksmes(3): ")
    if operationType == "1":
            logicIn = input("Ierakstiet loģisko izteiksmi ar a un p vertībām (piem. !a&p->a->(p|(a=a)^p)): ")
            print(getTruth(logicIn))
    elif operationType == "2":
        type = input("Konjuktīvais(k) vai disjunktīvais(d): ")
        count = int(input("Ievadiet mainīgo skaitu: "))
        inputs =  getInputs(count)
        if type == 'k':
            print(getCon(inputs, getGenericVars(count)))
        elif type == 'd':
            print(getDis(inputs, getGenericVars(count))) 
    elif operationType == "3":
        type = input("Konjuktīvais(k) vai disjunktīvais(d): ")
        logicIn = input("Ierakstiet loģisko izteiksmi ar mainīgo vertībām (piem. !A&B->C->(Q|(A=a)^M)): ")
        if type == 'k':
            print(findConFromExpr(logicIn))
        elif type == 'd':
            print(findDisFromExpr(logicIn))