Generate truth tables and abstract syntax trees from boolean expressions!
Example usage:
>>> from truth_tables import TruthTable
>>> my_table = TruthTable('p or q', '~p -> q', 'T and ~T')
>>> print(my_table)
┌───┬───┬────────┬─────────┬──────────┐
│ p │ q │ p or q │ ~p -> q │ T and ~T │
├───┼───┼────────┼─────────┼──────────┤
│ F │ F │ F │ F │ F │
│ F │ T │ T │ T │ F │
│ T │ F │ T │ T │ F │
│ T │ T │ T │ T │ F │
└───┴───┴────────┴─────────┴──────────┘
>>> print(my_table.ast)
Or
├─Var('p')
╰─Var('q')
Implies
├─Negate
│ ╰─Var('p')
╰─Var('q')
And
├─Const(True)
╰─Negate
╰─Const(True)
>>> my_table = TruthTable('~((p xor (q and ~r) or q) and ~(p <-> r))', binary=True)
>>> print(my_table)
┌───┬───┬───┬───────────────────────────────────────────┐
│ p │ q │ r │ ~((p xor (q and ~r) or q) and ~(p <-> r)) │
├───┼───┼───┼───────────────────────────────────────────┤
│ 0 │ 0 │ 0 │ 1 │
│ 0 │ 0 │ 1 │ 1 │
│ 0 │ 1 │ 0 │ 1 │
│ 0 │ 1 │ 1 │ 0 │
│ 1 │ 0 │ 0 │ 0 │
│ 1 │ 0 │ 1 │ 1 │
│ 1 │ 1 │ 0 │ 0 │
│ 1 │ 1 │ 1 │ 1 │
└───┴───┴───┴───────────────────────────────────────────┘
Two TruthTables
are equal if they have the same variables and the same truth values (not necessarily the same propositions).
>>> TruthTable('p -> q') == TruthTable('~p or q')
True
The parser will accept symbolic or english names for boolean operators:
┌──────────┬──────────┬─────────┬──────────────┐
│ operator │ symbolic │ english │ alternatives │
├──────────┼──────────┼─────────┼──────────────┤
│ Not │ ~ │ not │ │
│ And │ & │ and │ │
│ Or │ | │ or │ │
│ Implies │ -> │ implies │ then │
│ Iff │ <-> │ iff │ │
│ Xor │ ^ │ xor │ │
└──────────┴──────────┴─────────┴──────────────┘
Precedence is Not
, ()
, And
, then everything else.