Python-сообщество

class BrokenEgg(Exception):
    pass

class Brain_breacker:
    def __init__(self):
        self.test_exp = ""
        self.expect_operator = 0
        self.braces = 0
        self.operators = ("!", "&", "|", "==", "_")
        self.operator_leters = ("!", "&", "|", "=", "_")
        self.prefix_operators = ("!")
        self.var_begining = ("x", "y")

    def is_var(self, i):
        if self.test_exp[i] in ("x", "y"):
            return True

    def add_var(self, i):
        return i+1

    def check_operator_expection(self, i):
        if self.expect_operator:
            raise BrokenEgg("Expect operator after '%s'." % self.test_exp[:i])

    def check_other_expection(self, i):
        if not self.expect_operator:
            if self.test_exp[i] in self.prefix_operators:
                return True
            raise BrokenEgg("Don't expect operator after '%s'." % self.test_exp[:i])

    def is_operator(self, i):
        if self.test_exp[i] in self.operator_leters:
            return True

    def add_operator(self, i):
        j = i
        buf = ""
        while self.test_exp[j] in self.operator_leters:
            buf += self.test_exp[j]
            j += 1
            if buf in self.prefix_operators:
                return j
        if buf in self.operators:
            return j
        else:
            raise BrokenEgg("Operator '%s' doesn't exist." % buf)

    def start(self, expression):
        self.test_exp = expression
        i = 0
        while i < len(self.test_exp):
            #print i, " - ", self.test_exp[i], " - ", self.test_exp
            if self.test_exp[i] == "(":
                self.check_operator_expection(i)
                self.braces += 1
                self.expect_operator = False
                i += 1
                continue

            if self.test_exp[i] == ")":
                self.braces -= 1
                self.expect_operator = True
                i += 1
                continue

            if self.is_var(i):
                self.check_operator_expection(i)
                i = self.add_var(i)
                self.expect_operator = True
                continue

            if self.is_operator(i):
                self.check_other_expection(i)
                self.expect_operator = False
                i = self.add_operator(i)
                continue
            
            if self.test_exp[i] == " ":
                i += 1
                continue

            raise BrokenEgg("Unexpectable simbol '%s'." % self.test_exp[i])
        
        if self.braces:
            raise BrokenEgg("Something wrong with braces.")
        return True


def test(text, i = [0]):
    i[0] += 1
    print ">Test number %s:" % i[0]
    print "Test expression is '%s'." % text
    bb = Brain_breacker()
    try:
        bb.start(text)
        print "It's allright with '%s'" % text
    except BrokenEgg as e:
        print e
    print ""

test("(!x == y & x ! x & !(!x & !y))")
test("(!x + y & x ! x & !(!x & !y))")
test("(!x == y & x = x & !(!x & !y))")
test("(!x == (y) & (x ! x & !(!x & !y)))")
test("(!x == (y & (x ! x & !(!x & !y)))")

def is_prop_formula(string):
    def reduce(string):
        result = re.sub("\(?&[A-Z]\)?|\(?[A-Z]>[A-Z]\)?|\(?[A-Z]<[A-Z]\)?|\(?[A-Z]=[A-Z]\)?|\(?[A-Z]_[A-Z]\)?|\([A-Z]\)", "X", string)
        if result != string:
            return reduce(result)
        return result
    return reduce(string) == "X"

In [1]: is_prop_formula("(A=B)>(&C<D)=C=T>Z")
Out[1]: True
In [2]: is_prop_formula("+(A=B)>(&C<D)=C=T>Z")
Out[2]: False

def is_prop_formula(string):
    def reduce(string):
        result = re.sub("\(?&[A-Z]\)?|\(?[A-Z]>[A-Z]\)?|\(?[A-Z]<[A-Z]\)?|\(?[A-Z]=[A-Z]\)?|\(?[A-Z]_[A-Z]\)?|\([A-Z]\)", "X", string)
        if result != string:
            return reduce(result)
        return result
    return reduce(string) == "X"