¿Qué son las expresiones lógicas en Sympy?

SymPy es un paquete Python de matemáticas simbólicas. Su objetivo es convertirse en un sistema de álgebra computarizado con todas las funciones manteniendo el código lo más básico posible para que sea comprensible y ampliable. El paquete está completamente escrito en lenguaje python. Las expresiones lógicas en sympy se expresan mediante funciones booleanas. El módulo sympy.basic.booleanarg de sympy contiene funciones booleanas. 

Los operadores comunes de Python & (Y), | (O) y ~ (No) se pueden usar para crear expresiones booleanas. >> y también se puede utilizar para crear implicaciones. otras operaciones booleanas o puertas son NAND, NOR, XOR, etc.

Booleano Verdadero:

sympy.logic.boolalg.BooleanTrue

Boolean True en SymPy es un singleton al que se puede acceder con S.true, o importando directamente True o importando symplify desde el paquete sympy.

# import packages
from sympy import true
from sympy import S, sympify
  
# prints True
print(true)
  
# prints True
print(S.true)
  
# prints true
print(sympify(true))

Producción:

True
True
True

Falso booleano:

sympy.logic.boolalg.BooleanFalse

Boolean False en SymPy es un singleton al que se puede acceder con S.false, o importando directamente false o importando symplify desde el paquete sympy.

# import packages
from sympy import false
from sympy import S, sympify
  
# prints False
print(false)
  
# prints False
print(S.false)
  
# prints False
print(sympify(false))

Producción:

False
False
False

la negación de verdadero es falso, y la negación de falso es verdadero.

# import packages
from sympy import false, true
  
print(~true,~false)

Producción:

False True

booleano y:

sympy.logic.boolalg.Y

Analiza cada uno de sus argumentos en secuencia, devuelve verdadero si todos los argumentos son verdaderos. si al menos un argumento es falso, se devuelve falso.

• verdadero & verdadero = verdadero
• verdadero y falso = falso
• falso y verdadero = falso
• falso&falso = falso

# import packages
from sympy.abc import x, y
from sympy.logic.boolalg import And
  
res = x & y
print(res)
  
# 1&y ==y
print(And(x, y).subs(x, 1))
  
# 0&y ==0 or False
print(And(x, y).subs(x, 0))
  
# True&False == False
print(And(True, False))
  
# True & True == True
print(And(True, True))
  
# False & False == False
print(And(False, False))
  
# False & True == False
print(And(False, True))

Salida :

x & y
y
False
False
True
False
False

booleano o:

sympy.logic.boolalg.Or

Si alguno de los argumentos es verdadero, se devuelve verdadero o falso. 

• verdadero | verdadero = verdadero
• verdadero|falso = verdadero
• falso | verdadero = verdadero
• falso|falso = falso

# import packages
from sympy.abc import x, y
from sympy.logic.boolalg import Or
  
res = x | y
print(res)
  
# 1&y == 1 or True
print(Or(x, y).subs(x, 1))
  
# 0|y ==y
print(Or(x, y).subs(x, 0))
  
# True | False == True
print(Or(True, False))
  
# True | True == True
print(Or(True, True))
  
# False | False == False
print(Or(False, False))
  
# False | True == True
print(Or(False, True))

Producción:

x | y
True
y
True
True
False
True

Booleano No:

sympy.logic.boolalg.Not(arg)

No representa la negación. Si la declaración es Falsa, este método devuelve Verdadero. Si la afirmación es verdadera, devuelve Falso.

# import packages
from sympy.abc import x
from sympy.logic.boolalg import Not
  
# nor formula
print(Not(x))
  
# ~True == True
print(Not(True))
  
# ~False == False
print(Not(False))

Producción:

~x
False
True

Booleano Ni:

sympy.logic.boolalg.Nor(*argumentos)

Nor es una conjunción de Not y Or. Ni = No+O. Examina cada argumento a su vez, devolviendo Falso si alguno de ellos es Verdadero y Verdadero si todos ellos son Falso. Si algún argumento es Verdadero, devuelve Falso. Si todos los argumentos son falsos, esta función devuelve verdadero.

# import packages
from sympy.abc import x, y
from sympy.logic.boolalg import Nor
  
nor_formula = ~(x | y)
print(nor_formula)
print(Nor(x, y))
  
# ~( True | False) == False
print(Nor(True, False))
  
# ~(True | True) == False
print(Nor(True, True))
  
# ~(False | False) == True
print(Nor(False, False))
  
# ~(False | True) == False
print(Nor(False, True))

Producción:

~(x | y)
~(x | y)
False
False
True
False

Nand booleana:

sympy.logic.boolalg.Nand(*argumentos)

Nand es una conjunción de Not y. Ni = No+Y. Analiza cada una de sus entradas en sucesión, devolviendo True si alguna de ellas es False y False si todas ellas son True. Si alguna de las entradas es falsa, esta función devuelve verdadero. Si todos los argumentos son verdaderos, devuelve falso.

# import packages
from sympy.abc import x, y
from sympy.logic.boolalg import Nand
  
# not + nand == nand
nor_formula = ~(x & y)
print(nor_formula)
print(Nand(x, y))
  
# ~( True & False) == True
print(Nand(True, False))
  
# ~(True & True) == False
print(Nand(True, True))
  
# ~(False & False) == True
print(Nand(False, False))
  
# ~(False & True) == True
print(Nand(False, True))

Producción:

~(x & y)
~(x & y)
True
False
True
True

Xor booleano:

sympy.logic.boolalg.Xor(*argumentos)

Xor representa la función XOR lógico o O exclusivo. Si un número impar de argumentos es verdadero y los demás son falsos, esta función devuelve verdadero. Si un número par de argumentos es Verdadero y los demás son Falso, el resultado es Falso.

# import packages
from sympy.abc import x, y
from sympy.logic.boolalg import Xor
  
xor_formula = x ^ y
print(xor_formula)
print(Xor(x, y))
  
#  True ^ False == True
print(Xor(True, False))
  
# True ^ True == False
print(Xor(True, True))
  
# False ^ False == False
print(Xor(False, False))
  
# False ^ True == True
print(Xor(False, True))

Producción:

x ^ y
x ^ y
True
False
False
True

Booleano implica:

sympy.logic.boolalg.Implica(*argumentos)

Implica se refiere a implicaciones lógicas. x implica que y es equivalente a !xv y. Acepta x e y como entradas booleanas. Si x es Verdadero e y es Falso, devuelve Falso. De lo contrario, se devuelve True.

from sympy.abc import x, y
from sympy.logic.boolalg import Implies
  
# !A v B == implies formula
# returns false when A is true and B is 
# false, rest all cases returns True
print(Implies(x, y))
  
# false
print(Implies(True, False))
  
# true
print(Implies(True, True))
  
# true
print(Implies(False, False))
  
# true
print(Implies(False, True))
print(x << y)
print(x >> y)

Producción:

Implies(x, y)
False
True
True
True
Implies(y, x)
Implies(x, y)

Equivalente booleano

sympy.logic.boolalg.Equivalent(*args)

Se refiere a una relación de equivalencia. Si xey son verdaderos o falsos, Equivalente(x, y) es verdadero. Si todos los argumentos son lógicamente equivalentes, se devuelve True. De lo contrario, se devuelve False.

from sympy.abc import x, y, z
from sympy.logic.boolalg import Equivalent, And, Or
  
print(Equivalent(x, y, z))
  
# true != false so it returns false
print(Equivalent(True, False))
  
# True == True  so it returns true
print(Equivalent(True, True))
  
# False == False so it returns true
print(Equivalent(False, False))
  
# False !=True so it returns false
print(Equivalent(False, True))
  
# true ==true == true so it returns true
print(Equivalent(True, Or(True, False), And(True, True)))

Producción:

Equivalent(x, y, z)
False
True
True
False
True

ITE booleano:

sympy.logic.boolalg.ITE(*argumentos)

ITE se refiere a la cláusula If then else. Si A es verdadero, ITE(x, y, z) evalúa y devuelve el resultado de y; de lo contrario, ITE(x, y, z) evalúa y devuelve el resultado de z. Todos los argumentos deben ser booleanos.

from sympy.abc import x, y, z
from sympy.logic.boolalg import ITE, Nor, Nand, Xor, Or, And
  
# ITE == if then else
print(ITE(x, y, z))
  
# x is true so y is returned
print(ITE(True, Or(True, False), And(True, True)))
  
# x is false so z is returned
print(ITE(Nor(True, False), Xor(True, False), Nand(True, True)))

Producción:

ITE(x, y, z)
True
False