Symbolic and fuzzy booleans
Contents
Symbolic and fuzzy booleans¶
This page describes what a symbolic Boolean in SymPy is and also
how that relates to three-valued fuzzy-bools that are used in many parts of
SymPy. It also discusses some common problems that arise when writing code
that uses three-valued logic and how to handle them correctly.
Symbolic Boolean vs three valued bool¶
Assumptions queries like x.ispositive give fuzzy-bool True,
False or None results 1. These are low-level Python objects
rather than SymPy’s symbolic Boolean expressions.
>>> from sympy import Symbol, symbols
>>> xpos = Symbol('xpos', positive=True)
>>> xneg = Symbol('xneg', negative=True)
>>> x = Symbol('x')
>>> print(xpos.is_positive)
True
>>> print(xneg.is_positive)
False
>>> print(x.is_positive)
None
A None result as a fuzzy-bool should be interpreted as meaning “maybe” or
“unknown”.
An example of a symbolic Boolean class in SymPy can be found when
using inequalities. When an inequality is not known to be true or false a
Boolean can represent indeterminate results symbolically:
>>> xpos > 0
True
>>> xneg > 0
False
>>> x > 0
x > 0
>>> type(x > 0)
<class 'sympy.core.relational.StrictGreaterThan'>
The last example shows what happens when an inequality is indeterminate: we
get an instance of StrictGreaterThan which represents the
inequality as a symbolic expression. Internally when attempting to evaluate an
inequality like a > b SymPy will compute (a - b).is_extended_positive.
If the result is True or False then SymPy’s symbolic S.true or
S.false will be returned. If the result is None then an unevaluated
StrictGreaterThan is returned as shown for x > 0 above.
It is not obvious that queries like xpos > 0 return S.true rather than
True because both objects display in the same way but we can check this
using the Python is operator:
>>> from sympy import S
>>> xpos.is_positive is True
True
>>> xpos.is_positive is S.true
False
>>> (xpos > 0) is True
False
>>> (xpos > 0) is S.true
True
There is no general symbolic analogue of None in SymPy. In the cases where
a low-level assumptions query gives None the symbolic query will result in
an unevaluated symbolic Boolean (e.g, x > 0). We can use a
symbolic Boolean as part of a symbolic expression such as a
Piecewise:
>>> from sympy import Piecewise
>>> p = Piecewise((1, x > 0), (2, True))
>>> p
Piecewise((1, x > 0), (2, True))
>>> p.subs(x, 3)
1
Here p represents an expression that will be equal to 1 if x > 0
or otherwise it will be equal to 2. The unevaluated Boolean inequality
x > 0 represents the condition for deciding the value of the expression
symbolically. When we substitute a value for x the inequality will resolve
to S.true and then the Piecewise can evaluate to 1 or 2.
The same will not work when using a fuzzy-bool instead of a symbolic
Boolean:
>>> p2 = Piecewise((1, x.is_positive), (2, True))
Traceback (most recent call last):
...
TypeError: Second argument must be a Boolean, not `NoneType`
The Piecewise can not use None as the condition because unlike the
inequality x > 0 it gives no information. With the inequality it is
possible to decide in future if the condition might True or False
once a value for x is known. A value of None can not be used in that
way so it is rejected.
Note
We can use True in the Piecewise because True sympifies
to S.true. Sympifying None just gives None again which
is not a valid symbolic SymPy object.
There are many other symbolic Boolean types in SymPy. The same
considerations about the differences between fuzzy bool and symbolic
Boolean apply to all other SymPy Boolean types. To give
a different example there is Contains which represents the
statement that an object is contained in a set:
>>> from sympy import Reals, Contains
>>> x = Symbol('x', real=True)
>>> y = Symbol('y')
>>> Contains(x, Reals)
True
>>> Contains(y, Reals)
Contains(y, Reals)
>>> Contains(y, Reals).subs(y, 1)
True
The Python operator corresponding to Contains is in. A quirk of
in is that it can only evaluate to a bool (True or False) so
if the result is indeterminate then an exception will be raised:
>>> from sympy import I
>>> 2 in Reals
True
>>> I in Reals
False
>>> x in Reals
True
>>> y in Reals
Traceback (most recent call last):
...
TypeError: did not evaluate to a bool: (-oo < y) & (y < oo)
The exception can be avoided by using Contains(x, Reals) or
Reals.contains(x) rather than x in Reals.
Three-valued logic with fuzzy bools¶
Whether we use the fuzzy-bool or symbolic Boolean we always need to be
aware of the possibility that a query might be indeterminate. How to write
code that handles this is different in the two cases though. We will look at
fuzzy-bools first.
Consider the following function:
>>> def both_positive(a, b):
... """ask whether a and b are both positive"""
... if a.is_positive and b.is_positive:
... return True
... else:
... return False
The both_positive function is supposed to tell us whether or not a and
b are both positive. However the both_positive function will fail if
either of the is_positive queries gives None:
>>> print(both_positive(S(1), S(1)))
True
>>> print(both_positive(S(1), S(-1)))
False
>>> print(both_positive(S(-1), S(-1)))
False
>>> x = Symbol('x') # may or may not be positive
>>> print(both_positive(S(1), x))
False
Note
We need to sympify the arguments to this function using S
because the assumptions are only defined on SymPy objects and not
regular Python int objects.
Here False is incorrect because it is possible that x is positive in
which case both arguments would be positive. We get False here because
x.is_positive gives None and Python will treat None as “falsey”.
In order to handle all possible cases correctly we need to separate the logic
for identifying the True and False cases. An improved function might
be:
>>> def both_positive_better(a, b):
... """ask whether a and b are both positive"""
... if a.is_positive is False or b.is_positive is False:
... return False
... elif a.is_positive is True and b.is_positive is True:
... return True
... else:
... return None
This function now can handle all cases of True, False or None for
both a and b and will always return a fuzzy bool representing whether
the statement “a and b are both positive” is true, false or unknown:
>>> print(both_positive_better(S(1), S(1)))
True
>>> print(both_positive_better(S(1), S(-1)))
False
>>> x = Symbol('x')
>>> y = Symbol('y', positive=True)
>>> print(both_positive_better(S(1), x))
None
>>> print(both_positive_better(S(-1), x))
False
>>> print(both_positive_better(S(1), y))
True
Another case that we need to be careful of when using fuzzy-bools is negation
with Python’s not operator e.g.:
>>> x = Symbol('x')
>>> print(x.is_positive)
None
>>> not x.is_positive
True
The correct negation of a fuzzy bool None is None again. If we do not
know whether the statement “x is positive” is True or False then
we also do not know whether its negation “x is not positive” is True
or False. The reason we get True instead is again because None is
considered “falsey”. When None is used with a logical operator such as
not it will first be converted to a bool and then negated:
>>> bool(None)
False
>>> not bool(None)
True
>>> not None
True
The fact that None is treated as falsey can be useful if used correctly.
For example we may want to do something only if x is known to positive in
which case we can do
>>> x = Symbol('x', positive=True)
>>> if x.is_positive:
... print("x is definitely positive")
... else:
... print("x may or may not be positive")
x is definitely positive
Provided we understand that an alternate condition branch refers to two cases
(False and None) then this can be a useful way of writing
conditionals. When we really do need to distinguish all cases then we need to
use things like x.is_positive is False. What we need to be careful of
though is using Python’s binary logic operators like not or and with
fuzzy bools as they will not handle the indeterminate case correctly.
In fact SymPy has internal functions that are designed to handle fuzzy-bools correctly:
>>> from sympy.core.logic import fuzzy_not, fuzzy_and
>>> print(fuzzy_not(True))
False
>>> print(fuzzy_not(False))
True
>>> print(fuzzy_not(None))
None
>>> print(fuzzy_and([True, True]))
True
>>> print(fuzzy_and([True, None]))
None
>>> print(fuzzy_and([False, None]))
False
Using the fuzzy_and function we can write the both_positive function
more simply:
>>> def both_positive_best(a, b):
... """ask whether a and b are both positive"""
... return fuzzy_and([a.is_positive, b.is_positive])
Making use of fuzzy_and, fuzzy_or and fuzzy_not leads to simpler
code and can also reduce the chance of introducing a logic error because the
code can look more like it would in the case of ordinary binary logic.
Three-valued logic with symbolic Booleans¶
When working with symbolic Boolean rather than fuzzy-bool the issue of
None silently being treated as falsey does not arise so it is easier not
to end up with a logic error. However instead the indeterminate case will
often lead to an exception being raised if not handled carefully.
We will try to implement the both_positive function this time using
symbolic Boolean:
>>> def both_positive(a, b):
... """ask whether a and b are both positive"""
... if a > 0 and b > 0:
... return S.true
... else:
... return S.false
The first difference is that we return the symbolic Boolean objects
S.true and S.false rather than True and False. The second
difference is that we test e.g. a > 0 rather than a.is_positive.
Trying this out we get
>>> both_positive(1, 2)
True
>>> both_positive(-1, 1)
False
>>> x = Symbol('x') # may or may not be positive
>>> both_positive(x, 1)
Traceback (most recent call last):
...
TypeError: cannot determine truth value of Relational
What happens now is that testing x > 0 gives an exception when x is
not known to be positive or not positive. More precisely x > 0 does not
give an exception but if x > 0 does and that is because the if
statement implicitly calls bool(x > 0) which raises.
>>> x > 0
x > 0
>>> bool(x > 0)
Traceback (most recent call last):
...
TypeError: cannot determine truth value of Relational
>>> if x > 0:
... print("x is positive")
Traceback (most recent call last):
...
TypeError: cannot determine truth value of Relational
The Python expression x > 0 creates a SymPy Boolean. Since in this
case the Boolean can not evaluate to True or False we get an
unevaluated StrictGreaterThan. Attempting to force that into a
bool with bool(x > 0) raises an exception. That is because a regular
Python bool must be either True or False and neither of those
are known to be correct in this case.
The same kind of issue arises when using and, or or not with
symbolic Boolean. The solution is to use SymPy’s symbolic
And, Or and Not or equivalently Python’s
bitwise logical operators &, | and ~:
>>> from sympy import And, Or, Not
>>> x > 0
x > 0
>>> x > 0 and x < 1
Traceback (most recent call last):
...
TypeError: cannot determine truth value of Relational
>>> And(x > 0, x < 1)
(x > 0) & (x < 1)
>>> (x > 0) & (x < 1)
(x > 0) & (x < 1)
>>> Or(x < 0, x > 1)
(x > 1) | (x < 0)
>>> Not(x < 0)
x >= 0
>>> ~(x < 0)
x >= 0
As before we can make a better version of both_positive if we avoid
directly using a SymPy Boolean in an if, and, or, or not.
Instead we can test whether or not the Boolean has evaluated to S.true
or S.false:
>>> def both_positive_better(a, b):
... """ask whether a and b are both positive"""
... if (a > 0) is S.false or (b > 0) is S.false:
... return S.false
... elif (a > 0) is S.true and (b > 0) is S.true:
... return S.true
... else:
... return And(a > 0, b > 0)
Now with this version we don’t get any exceptions and if the result is
indeterminate we will get a symbolic Boolean representing the conditions
under which the statement “a and b are both positive” would be true:
>>> both_positive_better(S(1), S(2))
True
>>> both_positive_better(S(1), S(-1))
False
>>> x, y = symbols("x, y")
>>> both_positive_better(x, y + 1)
(x > 0) & (y + 1 > 0)
>>> both_positive_better(x, S(3))
x > 0
The last case shows that actually using the And with a condition that is
known to be true simplifies the And. In fact we have
>>> And(x > 0, 3 > 0)
x > 0
>>> And(4 > 0, 3 > 0)
True
>>> And(-1 > 0, 3 > 0)
False
What this means is that we can improve both_positive_better. The
different cases are not needed at all. Instead we can simply return the
And and let it simplify if possible:
>>> def both_positive_best(a, b):
... """ask whether a and b are both positive"""
... return And(a > 0, b > 0)
Now this will work with any symbolic real objects and produce a symbolic result. We can also substitute into the result to see how it would work for particular values:
>>> both_positive_best(2, 1)
True
>>> both_positive_best(-1, 2)
False
>>> both_positive_best(x, 3)
x > 0
>>> condition = both_positive_best(x/y, x + y)
>>> condition
(x + y > 0) & (x/y > 0)
>>> condition.subs(x, 1)
(1/y > 0) & (y + 1 > 0)
>>> condition.subs(x, 1).subs(y, 2)
True
The idea when working with symbolic Boolean objects is as much as possible
to avoid trying to branch on them with if/else and other logical operators
like and etc. Instead think of computing a condition and passing it around
as a variable. The elementary symbolic operations like And,
Or and Not can then take care of the logic for you.
Footnotes
- 1
Note that what is referred to in SymPy as a “fuzzy bool” is really about using three-valued logic. In normal usage “fuzzy logic” refers to a system where logical values are continuous in between zero and one which is something different from three-valued logic.