kevin-cfs
commented
4 years ago Update:
It seems that when you take an expression and run the simplify() function on it then it will sometimes give different results than parsing the string form of it will.
####################################################################### import boolean
algebra = boolean.BooleanAlgebra() a, b = algebra.symbols(*'ab')
logic = (a&b)|(~a|~b) print(str(logic)) print(str(logic.simplify())) print(str(algebra.parse(str(logic), simplify=True)))
logic = logic.simplify() print(str(logic.simplify())) print(str(algebra.parse(str(logic), simplify=True))) #######################################################################
In this example we have a very simple case that tests out the difference between the simplify() function and the algebra.parse() function. And these are the results.
print 1 ==> (a&b)|(~a|~b) print 2 ==> ~a|b|~b print 3 ==> ~a|b|~b print 4 ==> ~a|b|~b print 5 ==> 1
As you can see. Both simlify() and algebra.parse() make an attempt to simplify the expression and it has technically made progress but clearly isn't finished. Both of them manage to do the same amount of work on the original input. Next you take the output an run it through this process again but this time when the shorter logic of '~a|b|~b' is parsed with the algebra object from a string it actually does get simplified further. This does not happen in every case but I have found it to be true here in this one.
I would love for this to work properly every time because I cannot even rely on running these statements multiple times in order to get these expressions worked down. I have to use this simplification process thousands of times with logic that contains tens of terms. If it fails to work on these small examples it will surely work on the much larger ones.
pombredanne
I am utilizing this code in a project of mine and am finding I have some really long boolean logic when I finish. I am relying heavily on the simplification component in order to make my whole project work but I realize that it doesn't seem to work as well as Wolfram Alpha. Here is a simple test.
logic = "( a & ~b & ~c )|( a & ( b | c ))"
According to Wolfram Alpha this evaluates to just 'a' but boolean.BooleanAlgebra(logic, simplify=True) doesn't change the results at all. This is a big issue for me. Has anyone else experienced the simplification not working effectively sometimes?
To further show this you can simplify this expression. logic = "(~b & ~c) | (b | c)" The result should be 1 or TRUE but the boolean parser gives a clearly wrong answer of "b|c|~c". But how can you ever have "c or not c"? That is clearly wrong.