A programming language can be easily used to automate the generation of a given truth table.

It helps to understand the manual method for constructing extended truth tables before trying the programmed method. If you are unsure about the manual method, see Truth tables: manual method .

Consider the following (fully parenthesized) logical expression that is given.

Here is the extended truth table for this logical expression.

Again, if you are unsure about the manual method, see Truth tables: manual method .

Here is an expression tree for the above logical expression.
The goal now is to write a program that automates this process for this specific expression.

The first step is to give each logical operator in the logical expression a distinct name. Here the variables are named with a single letter starting at A. Here is the expression.

Here are the variables needed.

• A corresponds to the leftmost "&" (and)
• B corresponds to the only "|" (or)
• C corresponds to the leftmost "!" (not)
• D corresponds to the rightmost "&" (and)
• E corresponds to the rightmost "!" (not)

Note that upper case letters are used here, but the actual variables in program code will (usually) be lowercase letters.

Here is the expression written using operators and the expression written using variables for comparison.

Here is the expression tree using operators.

Here is the expression tree using variables.

We need a way to do logical operations of x and y where x and y are integers.

• negation: ! x is 1 - x
• conjunction: x & y is x * y
• disjunction: x | y is x + y - x*y
• exclusive or: x ^ y is (x + y) % 2
• equality: x = y is x + y + 1

To verify the above, check every possible combination. See Boolean operations using integers .

Assume that the values in variables x and y are valid. That is, only 1 or 0. Then a sequence of assignment statements can be used to compute all of the results in the following manner.

Such a sequence of assignments follows the diagram as the data and result flow from leaves at the bottom of the tree to the final result at the top of the tree.

Here is the Python code [#1]
def ttDo1(x, y): a = x * y c = 1 - x e = 1 - y d = c * e b = a + d - a*d print("{0:d} {1:d} | ( {2:d} {3:d} {4:d} ) {5:d} ( ( {6:d} {7:d} ) {8:d} ( {9:d} {10:d} ) )".format(x,y,x,a,y,b,c,x,d,e,y)) print("x y | ( x & y ) | ( ( ! x ) & ( ! y ) )") print("---------------------------------------") ttDo1(0,0) ttDo1(0,1) ttDo1(1,0) ttDo1(1,1)
Here is the output of the Python code.
x y | ( x & y ) | ( ( ! x ) & ( ! y ) ) --------------------------------------- 0 0 | ( 0 0 0 ) 1 ( ( 1 0 ) 1 ( 1 0 ) ) 0 1 | ( 0 0 1 ) 0 ( ( 1 0 ) 0 ( 0 1 ) ) 1 0 | ( 1 0 0 ) 0 ( ( 0 1 ) 0 ( 1 0 ) ) 1 1 | ( 1 1 1 ) 1 ( ( 0 1 ) 0 ( 0 1 ) )

Now let us write the same program using the Python walrus operator to assign subexpression values to variables.

Here is the Python code [#2]
def ttDo1(x, y): b = (a:= x*y)+(d:= (c:= 1-x)*(e:= 1-y))-(a*d) print("{0:d} {1:d} | ( {2:d} {3:d} {4:d} ) {5:d} ( ( {6:d} {7:d} ) {8:d} ( {9:d} {10:d} ) )".format(x,y,x,a,y,b,c,x,d,e,y)) print("x y | ( x & y ) | ( ( ! x ) & ( ! y ) )") print("---------------------------------------") ttDo1(0,0) ttDo1(0,1) ttDo1(1,0) ttDo1(1,1)
Here is the output of the Python code.
x y | ( x & y ) | ( ( ! x ) & ( ! y ) ) --------------------------------------- 0 0 | ( 0 0 0 ) 1 ( ( 1 0 ) 1 ( 1 0 ) ) 0 1 | ( 0 0 1 ) 0 ( ( 1 0 ) 0 ( 0 1 ) ) 1 0 | ( 1 0 0 ) 0 ( ( 0 1 ) 0 ( 1 0 ) ) 1 1 | ( 1 1 1 ) 1 ( ( 0 1 ) 0 ( 0 1 ) )

The walrus operator can make for more compact code. But is it more clear than explicit assignment statements?