Numbers as Boolean Functions - Online Math Tutor Juan Castaneda, MS


» Numbers as Boolean Functions «

Stirling Numbers

The Multiplication Table

Factored Integers

The Circle





Slope-Intercept Equation

Complex Numbers

Calculator TI-89

Tower of Hanoi

Please support this site by giving a donation in the amount of your choosing. Send it to: via because with your help we can increase and improve the mathematical information you can find in here.

The Number of a Boolean Function

In this page we present a non-negative integer functional, defined on the set of all Boolean functions of a finite number of Boolean variables.
This function assigns a unique integer between 0 and 22n- 1 to each Boolean function of n Boolean variables.

Opening the possibility of casting Boolean Algebra and Logic into an all-numerical language
  • Ordering Boolean Functions in Increasing Sequences
  • Whole Numbers associated to Boolean Expressions
  • Truth Tables are naturally ordered as binary numbers
  • Every Logic Gate can be expressed by means of a single number
  • Multi-tiered correspondence between whole numbers and truth tables
  • From Boolean expresssion to Boolean function to truth table to binary number, and back

Counting Boolean expressions and Boolean functions (of n variables)
  • Infinitely many Boolean expressions vs. only a finite number of Boolean functions
  • Infinitely many Boolean expressions are equivalent to the same Boolean function

Given a whole number n, and given n Boolean variables x1, ..., xn, there are a denumerable infinite number of equivalent Boolean expressions defined on these n variables.

Equivalent Boolean expressions represent the same Boolean function.
For example, not(A) or not(B) is equivalent to the expression not(A and B).
Representing the same Boolean function, equivalent Boolean expressions have the same truth table.

Even though there are infinitely many Boolean expressions defined on n Boolean variables, the number of different Boolean functions defined on n variables is finite.

A Boolean function f of n Boolean variables x1, ..., xn, assigns a well-defined Boolean value f(x1, ..., xn) to each and every possible combination of values of the variables x1, ..., xn.

Boolean values are the two logic constants True, and False.
In linking truth tables to numbers via the binary system, we represent the Boolean value True with the binary digit 1, and the value False with the binary digit 0, respectively.

So, for n independent Boolean variables, each taking one particular Boolean value, there are 2n different possible combinations. A Boolean function has to assign one Boolean value to each one of these combinations.
This brings the number of different possible Boolean functions of n variables to a total of 22n

For example, when n = 2 (two variables), there are 22 = 4 possible combinations of Boolean values for those two variables:
(True,True), (True,False), (False,True), and (False,False). We call these combinations "cases."
There are 24 = 16 different Boolean functions of two variables covering the above four cases.

For three Boolean variables (n = 3), there are 23 = 8 different cases, giving us a total of 28 = 256 Boolean functions of 3 variables.

When n = 1 we have only one Boolean variable that can take either Boolean value, so we have only 21 = 2 different cases. This produces 22 = 4 Boolean functions of one Boolean variable.

A truth table is basically a case-by-case, explicitly spelled-out description of a Boolean function in full detail.
The truth table of a Boolean function lists the n variables, and all their 2n possible cases, together with the particular values the function assigns to each case.

How to convert a number into a Boolean function
(Numerical example with n = 2009)

First we express the number as a sum of powers of 2:

2009 = 1024 + 512 + 256 + 128 + 64 + 16 + 8 + 1

2009 = 210 + 29 + 28 + 27 + 26 + 24 + 23 + 20

Then we look at the exponents, and express them in binary notation:

2009 = 2(1010)2 + 2(1001)2 + 2(1000)2 + 2(0111)2 + 2(0110)2 + 2(0100)2 + 2(0011)2 + 2(0001)2

Next, we focus on the exponents only, and we list them all (still in binary notation):

(1010)2, (1001)2, (1000)2, (0111)2, (0110)2, (0100)2, (0011)2, (0001)2

The number 2009 is therefore assigned the following Boolean algebra expression as a sum of products
(by reading each binary number in the above list backwards, from right to left):

abcd + abcd + abcd + abcd + abcd + abcd + abcd + abcd

Then we can re-write the above Boolean algebra expression into an equivalent, somewhat reduced logical notation as follows:

[ (d xor c) & (a ⇒ (b = c)) ] or [ a & (c nor d) ]

In this way we are able to uniquely identify the truth table of this Boolean expression with the number 2009.

How to convert a Boolean expression into a number

Let's take. for example, the Boolean expression in four variables:

(a ⇒ b) & (b ⇒ c) & (c ⇒ d)

The first step is to identify the Boolean function described by the above expression.
To this effect, we find all possible cases (combinations of values of the variables) where the Boolean expression evaluates to True.
Then we list those cases, writing down the equivalent Boolean algebra expression as a sum of products:

abcd + abcd + abcd + abcd + abcd

Notice that every term in the sum shows all the variables (or their negation), and in the exact same order, from first to last.
(The order of the terms in the sum is not important but the order of the variables in each product is essential to find the number we are looking for)

The next step is to re-write the above sum as a list of binary numbers.
We read each product backwards (from right to left), replacing each plain variable with the binary digit 1, and each negated variable with the binary digit 0, as follows:

(1111)2, (1110)2, (1100)2, (1000)2, (0000)2

The reason for doing that transliteration backwards (from right to left) is because the first variable (a) corresponds to the lowest exponent (0), the second variable (b) corresponds to the second lowest exponent (1), the third variable (c) corresponds to the third lowest exponent (2), and so on and so forth.

Now we are ready to calculate the corresponding number as a sum of powers of 2, using the binary numbers in the previous list as exponents:

2(1111)2 + 2(1110)2 + 2(1100)2 + 2(1000)2 + 2(0000)2 =

= 215 + 214 + 212 + 28 + 20 =

= 32768 + 16384 + 4096 + 256 + 1 = 53505

Therefore 53505 is the number that represents the Boolean expression (a ⇒ b) & (b ⇒ c) & (c ⇒ d)
(and it also represents all equivalent Boolean expressions associated with the same Boolean function of four variables)

General formula to calculate the number assigned to a Boolean function

The number assigned here to a Boolean function f of m Boolean variables, equals the sum of powers of 2, taken over the set of those Boolean vectors (x1,..xm) that are assigned the value True by the function f, and where the exponent of each term is in turn a sum of powers of 2, that given by taking as exponents the predecessors of those sub-indexes k such that the Boolean variable xk is True in the vector (x1,..,xm).

This is the formula:

The general formula for assigning a number to a Boolean function

For the above formula to make sense, we interpret the Boolean values true and false, as their arithmetic equivalents 1 and 0, respectively.

As immediate consequences of the above formula we have:

If True, False, f, and g are Boolean functions of m Boolean variables, then

  1. N(False) = 0
  2. N(True) = 22m- 1
  3. If g(x1,..,xm) = ¬( f(x1,..,xm) ) for all Boolean vectors (x1,..,xm); then N(f) + N(g) = 22m- 1

Arity determines the interpretation of a number as a Boolean function

When using numbers to represent Boolean Functions, the meaning of a number as a Boolean Function (with the only exception of zero), will vary depending on the arity, the number of Boolean variables taken as input by the function.

0() = 0(a) = 0(a,b) = 0(a,b,c) = 0(a,b,c,d) = 0(a,b,c,d,e) = ... = False


As a 0-ary functionAs a unary functionAs a binary functionAs a ternary function
n = 1 1() = True 1(A) = ¬A 1(A,B) = A nor B 1(A,B,C) = (¬A) & (¬B) & (¬C)
n = 2 n/a 2(A) = A 2(A,B) = A & (¬B) 2(A,B,C) = A & (¬B) & (¬C)
n = 3 n/a 3(A) = True 3(A,B) = ¬B 3(A,B,C) = B nor C
n = 4 n/a n/a 4(A,B) = (¬A) & B 4(A,B,C) = (¬A) & B & (¬C)

Under this correspondence, every whole number is associated with a denumerable infinite number of Boolean functions.
However, each whole number is associated with at most one Boolean function of a given arity.

Zero and One are the only numbers that have an associated Boolean function for any given arity, including the two 0-ary, constant functions True and False.

Bigger numbers include cases that verify higher variables

The four truth tables defined on one Boolean variable A

Here we have the four different Boolean functions of one Boolean variable, each represented by their corresponding truth table. They are listed in order of their corresponding number.

Note: The number of truth tables grows very fast (exponentially-exponentially) with the number of Boolean variables considered (for example, for three variables alone we already have 256 different truth tables).

So, in view of the large number of different truth tables for a fixed number n of Boolean variables, we write one truth table per row, so we can go vertically listing as many tables as needed.
In this format, each Boolean case (combination of the individual values taken by the variables) is represented by a column of height n (the number of variables). We highlight these columns in green.

Notice that the cases are arranged so that each truth table, when read from left to right, looks exactly like the binary representation of the number assigned to that Boolean function.

0=00=FalseConstant function False, producing the value False regardless of the value of A
1=01=¬ANegation function, producing the Boolean value opposite to the value of A
2=10=AIdentity function, producing the same value as given by the input variable A
3=11=TrueConstant function True, producing the value True regardless of the value of A

The 16 truth tables defined on two Boolean variables A, B

Again, we write one truth table per row.
The number of each Boolean function is given in the leftmost column.
The four possible cases for two variables are highlighted in green, one case per column at the top of the table.

Notice that the cases are arranged so that each truth table, when read from left to right, looks exactly like the binary representation of the number assigned to that Boolean function.

Here we also include extra columns showing the interpretation of each number / Boolean function as:

  • a set of a smaller numbers,
  • a hypergraph, and
  • an event in a random experiment with 2 independent binary-outcome trials.

A:1010Boolean functionSetHypergraphEvent
0=0000=False=Empty set=No structure=No outcome
1=0001=A nor B={0}={ {} }=#(heads) = 0
2=0010=A & ¬B={1}={ {0} }=heads, tails
3=0011=¬B={0,1}={ {},{0} }=2nd coin = tails
4=0100=¬A & B={2}={ {1} }=tails, heads
5=0101=¬A={0,2}={ {},{1} }=1st coin = tails
6=0110=A xor B={1,2}={ {0},{1} }=#(heads) = 1
7=0111=A nand B=(0,1,2}={ {},{0},{1} }=#(heads) < 2
8=1000=A & B={3}={ {0,1} }=#(heads) = 2
9=1001=A = B={0.3}={ {},{0,1} }=#(heads) = even
10=1010=A={1,3}={ {0},{0,1} }=1st coin = heads
11=1011=A ⇐ B={0,1,3}={ {},{0},{0,1} }=1st = heads or 2nd = tails
12=1100=B={2,3}={ {1},{0,1} }=2nd coin = heads
13=1101=A ⇒ B={0,2,3}={ {},{1},{0,1} }=1st = tails or 2nd = heads
14=1110=A or B={1,2,3}={ {0},{1},{0,1} }=#(heads) > 0
15=1111=True={0,1,2,3}={ {},{0},{1},{0,1} }=Any outcome

Some of the 256 truth tables defined on three Boolean variables A, B, C

Please note: This particular section is still under construction. Thank you for your patience and understanding.

Here each truth table covers the eight cases possible for the three variables. Again, we write one truth table per row.
The number of each truth table / Boolean function is given in the leftmost column.
The eight possible cases for three variables are highlighted in green, one case per column at the top of the table.

Notice that the cases are arranged so that each truth table, when read from left to right, looks exactly like the binary representation of the number assigned to that Boolean function.

If you compare the Boolean expressions of the first 16 truth tables of three variables (given below), with the Boolean expressions of the 16 truth tables of two variables (in the previous section), you may notice a pattern:

For any number from 1 to 15, its Boolean expression in three variables (A, B, C), can be obtained from the corresponding Boolean expression in two variables (A, B), by adding the condition "& (¬C)" [read: "and not C"] at the end.

The same observation is applicable in general for "extending the meaning" of a number as a Boolean function to a longer range of truth tables as new variables are introduced.

A:10101010Boolean functionSet
0=00000000=False=Empty set
1=00000001=¬A & ¬B & ¬C={0}
2=00000010=A & (B nor C)={1}
3=00000011=B nor C={0,1}
4=00000100=(A nor C) & B={2}
5=00000101=A nor C={0,2}
6=00000110=(A = B) nor C={1,2}
7=00000111=(A & B) nor C={0,1,2}
8=00001000=(A nand B) nor C={3}
9=00001001=(A xor B) nor C={0,3}
10=00001010=A & ¬ C={1,3}
11=00001011=(B ⇒ A) & ¬C={0,1,3}
12=00001100=B & ¬C={2,3}
13=00001101=(A ⇒ B) & ¬C={0,2,3}
14=00001110=(A nor B) nor C={1,2,3}
16=00010000=(A nor B) & C={4}
17=00010001=A nor B={0,4}
18=00010010=(A = C) nor B={1,4}
19=00010011=(A & C) nor B={0,1,4}
20=00010100=A nor (B = C)={2,4}
21=00010101=A nor (B & C)={0,2,4}
22=00010110=(A nand B) & [A = (B = C)]={1,2,4}
23=00010111=[(A xor B) ⇒ C] ⇒ (A nor B)={0,1,2,4}
24=00011000=(A = B) & (A xor C)={3,4}
25=00011001=(A = B) & (A nand C)={0,3,4}
26=00011010=(A xor C) & (B ⇒ A)={1,3,4}
27=00011011=(A nor B) = (A ⇒ C)={0,1,3,4}
28=00011100=(A ⇒ B) & (B xor C)={2,3,4}
29=00011101=(A nor B) = (B ⇒ C)={0,2,3,4}
30=00011110=(A or B) xor C={1,2,3,4}
31=00011111=(A or B) nand C={0,1,2,3,4}
32=00100000=(A nand C) nor B={5}
33=00100001=(A xor C) nor B={0,5}
34=00100010=A & ¬B={1,5}
35=00100011= (C ⇒ A) & ¬B={0,1,5}
36=00100100=(A xor B) & (A = C)={2,5}
37=00100101=(A nor B) & (A = C)={0,2,5}
38=00100110=(A xor B) & (C ⇒ A)={1,2,5}
39=00100111=(A nor C) = (A ⇒ B)={0.1.2,5}
40=00101000=A & (B xor C)={3,5}
41=00101001=[A or B or C] ⇒ [A & (B xor C)]={0,3,5}
42=00101010=A & (B nand C)={1,3,5}
43=00101011=[A ⇒ B] nand [(A = B) ⇒ C]={0,1,3,5}
44=00101100=(C ⇒ A) & (B xor C)={2,3,5}
45=00101101=(A ⇒ B) xor C={0,2,3,5}
46=00101110=(A nor B) = (B & C)={1,2,3,5}
47=00101111=(A ⇒ B) nand C={0,1,2,3,5}
48=00110000=C & ¬B={4,5}
49=00110001=(A ⇒ C) & ¬B={0,4,5}
50=00110010=(A nor C) nor B={1,4,5}
52=00110100=(A ⇒ C) & (B xor C)={2,4,5}
53=00110101=(A nor C) = (C ⇒ B)={0,2,4,5}
54=00110110=(A or C) xor B={1,2,4,5}
55=00110111=(A or C) nand B={0,1,2,4,5}
56=00111000=(B xor C) & (A or C)={3,4,5}
57=00111001=(A ⇒ C) xor B={0,3,4,5}
58=00111010=(A nor C) = (B & C)={1,3,4,5}
59=00111011=(A ⇒ C) nand B={,5}
60=00111100=B xor C={2,3,4,5}
61=00111101=(B = C) ⇒ (A nor B)={0,2,3,4,5}
62=00111110=(B = C) ⇒ (A & ¬B)={1,2,3,4,5}
63=00111111=B nand C={0,1,2,3,4,5}
64=01000000=(A nand C) nor B={6}
65=01000001=(B xor C) nor A={0.6}
66=01000010=(B = C) & (A xor B)={1,6}
67=01000011=(B = C) & (A nand B)={0,1,6}
68=01000100=B & ¬A={2,6}
69=01000101=(C ⇒ B) & ¬A={0,2,6}
70=01000110=[B ⇒ A] nand [A ⇒ (B or C)]={1,2,6}
71=01000111=(B nor C) = (B ⇒ A)={0,1,2,6}
72=01001000=(A xor C) & B={3,6}
73=01001001=[(A xor B) = C] & [C ⇒ B]={0,3,6}
74=01001010=(A or B) & (A xor C)={1,3,6}
75=01001011=(B ⇒ A) xor C={0,1,3,6}
76=01001100=(A nand C) & B={2,3,6}
77=01001101=[A nor C] or [B & (A xor C)]={0.2,3,6}
78=01001110=(A nor B) = (A & C)={1,2,3,6}
79=01001111=(B ⇒ A) nand C={0.1,2,3,6}
80=01010000=C & ¬A={4,6}
81=01010001=(B ⇒ C) & ¬A={0,4,6}
82=01010010=(B ⇒ C) & (A xor C)={1,4,6}
83=01010011=(B nor C) = (C ⇒ A)={0,1,4,6}
84=01010100=A nor (B nor C)={2,4,6}
86=01010110=A xor (B or C)={1,2,4,6}
87=01010111=A nand (B or C)={0,1,2,4,6}
88=01011000=(A ⇒ B) & (A xor C)={3,4,6}
89=01011001=(B ⇒ C) xor A={0,3,4,6}
90=01011010=A xor C={1,3,4,6}
91=01011011=(A = C) ⇒ (A nor B)={0,1,3,4,6}
92=01011100=(A & C) = (B nor C)={2,3,4,6}
93=01011101=(B ⇒ C) nand A={0,2,3,4,6}
94=01011110=(A = C) ⇒ (¬A & B)={1,2,3,4,6}
95=01011111=A nand C={0,1,2,3,4,6}
96=01100000=(A xor B) & C={5,6}
97=01100001=[(B = C) ⇒ A] ⇒ [(A xor B) & C]={0,5,6}
98=01100010=(A xor B) & (B ⇒ C)={1,5,6}
99=01100011=(C ⇒ A) xor B={0,1,5,6}
100=01100100=(A ⇒ C) & (A xor B)={2,5,6}
101=01100101=(C ⇒ B) xor A={0,2,5,6}
102=01100110=A xor B={1,2,5,6}
103=01100111=(A = B) ⇒ (A nor C)={0,1,2,5,6}
104=01101000=[A & (B xor C)] or [(A xor B) & C]={3,5,6}
105=01101001=(A = B) xor C={0,3,5,6}
106=01101010=(B & C) xor A={1,3,5,6}
107=01101011=[(B xor C) ⇒ A] & [C ⇒ (A xor B)]={0,1,3,5,6}
108=01101100=(A & C) xor B={2,3,5,6}
109=01101101=[B or (A = C)] & [C ⇒ (A xor B)]={0,2,3,5,6}
110=01101110=(A = B) nand (A ⇒ C)={1,2,3,5,6}
111=01101111=(A = B) nand C={0,1,2,3,5,6}
112=01110000=(A nand B) & C={4,5,6}
113=01110001=[(A or B) ⇒ C] & ¬[A & B & C]={0,4,5,6}
114=01110010=(A & B) = (A nor C)={1,4,5,6}
115=01110011=(C ⇒ A) nand B={0,1,4,5,6}
116=01110100=(A & B) = (B nor C)={2,4,5,6}
117=01110101=(C ⇒ B) nand A={0,2,4,5,6}
118=01110110=(A = B) ⇒ (¬A & C)={1,2,4,5,6}
119=01110111=A nand B={0,1,2,4,5,6}
120=01111000=(A & B) xor C={3,4,5,6}
121=01111001=[(A xor B) ⇒ C] & ¬[A & B & C]={0,3,4,5,6}
122=01111010=(A ⇒ B) nand (A = C)={1,3,4,5,6}
123=01111011=(A = C) nand B={0,1,3,4,5,6}
124=01111100=(B = C) nand (B ⇒ A)={2,3,4,5,6}
125=01111101=(B = C) nand A={0,2,3,4,5,6}
126=01111110=(A = B) ⇒ (A xor C)={1,2,3,4,5,6}
127=01111111=¬A or ¬B or ¬C={0,1,2,3,4,5,6}
128=10000000=A & B & C={7}
129=10000001=(A = B) & (A = C)={0,7}
130=10000010=(B = C) & A={1,7}
131=10000011=(B = C) & (B ⇒ A)={0,1,7}
132=10000100=(A = C) & B={2,7}
133=10000101=(A ⇒ B) & (A = C)={0,2,7}
134=10000110=[(A xor B) ⇒ C] ⇒ [A & B & C]={1,2,7}
135=10000111=(A & B) = C={0,1,2,7}
136=10001000=A & B={3,7}
137=10001001=(A = B) & (C ⇒ A)={0,3,7}
138=10001010=(C ⇒ B) & A={1,3,7}
139=10001011=(A nand B) xor (B or C)={0,1,3,7}
140=10001100=(C ⇒ A) & B={2,3,7}
141=10001101=(A nand B) xor (A or C)={0,2,3,7}
142=10001110=[(A or B) ⇒ C] ⇒ [A & B & C]={1,2,3,7}
143=10001111=(A nand B) nand C={0,1,2,3,7}
144=10010000=(A = B) & C={4,7}
145=10010001=(A = B) & (A ⇒ C)={0,4,7}
146=10010010=[B or (A = C)] ⇒ [C & (A = B)]={1,4,7}
147=10010011=(A & C) = B={0,1,4,7}
148=10010100=[(B xor C) ⇒ A] ⇒ [C & (A = B)]={2,4,7}
149=10010101=(B & C) = A={0,2,4,7}
150=10010110=(A = B) = C={1,2,4,7}
151=10010111=[A ⇒ (B = C)] & [C ⇒ (B = A)]={0,1,2,4,7}
152=10011000=(A = B) & (A or C)={3,4,7}
153=10011001=A = B={0,3,4,7}
154=10011010=(C ⇒ B) = A={1,3,4,7}
155=10011011=(B or C) ⇒ (A = B)={0,1,3,4,7}
156=10011100=(C ⇒ A) = B={2,3,4,7}
157=10011101=(A or C) ⇒ (A = B)={0,2,3,4,7}
158=10011110=[(B = C) ⇒ A] & [C ⇒ (A = B)]={1,2,3,4,7}
159=10011111=(A xor B) nand C={0,1,2,3,4,7}
160=10100000=A & C={5,7}
161=10100001=(A = C) & (B ⇒ A)={0,5,7}
162=10100010=(B ⇒ C) & A={1,5,7}
163=10100011=(A & C) xor (B nor C)={0,1,5,7}
164=10100100=(A = C) & (A or B)={2,5,7}
165=10100101=A = C={0,2,5,7}
166=10100110=(B ⇒ C) = A={1,2,5,7}
167=10100111=(B or C) ⇒ (A = C)={0,1,2,5,7}
168=10101000=(B or C) & A={3,5,7}
169=10101001=(B or C) = A={0,3,5,7}
171=10101011=(B or C) ⇒ A={0,1,3,5,7}
172=10101100=(A & C) or (B & ¬C)={2,3,5,7}
173=10101101=(B ⇒ C) nand (A xor C)={0,2,3,5,7}
174=10101110=(B ⇒ C) ⇒ A={1,2,3,5,7}
175=10101111=C ⇒ A={0,1,2,3,5,7}
176=10110000=(B ⇒ A) & C={4,5,7}
177=10110001=(A or B) xor (A nand C)={0,4,5,7}
178=10110010=[A nor C] nor [B & (A xor C)]={1,4,5,7}
179=10110011=(A nand C) nand B={0,1,4,5,7}
180=10110100=(B ⇒ A) = C={2,4,5,7}
181=10110101=(A or B) ⇒ (A = C)={0,2,4,5,7}
182=10110110=[(A xor B) = C] nand [C ⇒ B]={1,2,4,5,7}
183=10110111=(A xor C) nand B={0,1,2,4,5,7}
184=10111000=(A & B) or (¬B & C)={3,4,5,7}
185=10111001=[B ⇒ A] & [A ⇒ (B or C)]={0,3,4,5,7}
186=10111010=(C ⇒ B) ⇒ A={1,3,4,5,7}
187=10111011=B ⇒ A={0,1,3,4,5,7}
188=10111100=(B = C) ⇒ (A & B)={2,3,4,5,7}
189=10111101=(A = B) or (B xor C)={0,2,3,4,5,7}
190=10111110=(B = C) ⇒ A={1,2,3,4,5,7}
191=10111111=(B & C) ⇒ A={0,1,2,3,4,5,7}
192=11000000=B & C={6,7}
193=11000001=(B = C) & (A ⇒ B)={0,6,7}
194=11000010=(B = C) & (A or B)={1,6,7}
195=11000011=B = C={0,1,6,7}
196=11000100=(A ⇒ C) & B={2,6,7}
197=11000101=(A or C) xor (B nand C)={0,2,6,7}
198=11000110=(A ⇒ C) = B={1,2,6,7}
199=11000111=(A or C) ⇒ (B = C)={0,1,2,6,7}
200=11001000=(A or C) & B={3,6,7}
201=11001001=(A or C) = B={0,3,6,7}
202=11001010=(B & C) or (A & ¬C)={1,3,6,7}
203=11001011=(A ⇒ C) nand (B xor C)={0,1,3,6,7}
205=11001101=(A or C) ⇒ B={0,2,3,6,7}
206=11001110=(A ⇒ C) ⇒ B={1,2,3,6,7}
207=11001111=C ⇒ B={0,1,2,3,6,7}
208=11010000=(A ⇒ B) & C={4,6,7}
209=11010001=(A or B) xor (B nand C)={0,4,6,7}
210=11010010=(A ⇒ B) = C={1,4,6,7}
211=11010011=(A or B) ⇒ (B = C)={0,1,4,6,7}
212=11010100=[A ⇒ B] & [(A = B) ⇒ C]={2,4,6,7}
213=11010101=(B nand C) nand A={0,2,4,6,7}
214=11010110=[A or B or C] & [A ⇒ (B = C)]={1,2,4,6,7}
215=11010111=(B xor C) nand A={0,1,2,4,6,7}
216=11011000=(A & B) or (¬A & C)={3,4,6,7}
217=11011001=(A = B) or (C & ¬A)={0,3,4,6,7}
218=11011010=(A = C) ⇒ (A & B)={1,3,4,6,7}
219=11011011=(A = C) ⇒ (B = C)={0,1,3,4,6,7}
220=11011100=(C ⇒ A) ⇒ B={2,3,4,6,7}
221=11011101=A ⇒ B={0,2,3,4,6,7}
222=11011110=(A = C) ⇒ B={1,2,3,4,6,7}
223=11011111=(A & C) ⇒ B={0,1,2,3,4,6,7}
224=11100000=(A or B) & C={5,6,7}
225=11100001=(A or B) = C={0,5,6,7}
226=11100010=(B & C) or (A & ¬B)={1,5,6,7}
227=11100011=(A ⇒ B) nand (B xor C)={0,1,5,6,7}
228=11100100=(A & C) or (¬A & B)={2,5,6,7}
229=11100101=(B ⇒ A) ⇒ (A = C)={0,2,5,6,7}
230=11100110=(A = B) ⇒ (B & C)={1,2,5,6,7}
231=11100111=(A = B) ⇒ (B = C)={0,1,2,5,6,7}
232=11101000=[(A xor B) ⇒ C] & (A or B)={3,5,6,7}
233=11101001=[A = (B = C)] ⇒ (A & B)={0,3,5,6,7}
234=11101010=(B & C) or A={1,3,5,6,7}
235=11101011=(B = C) or A={0,1,3,5,6,7}
236=11101100=(A & C) or B={2,3,5,6,7}
237=11101101=(A = C) or B={0,2,3,5,6,7}
238=11101110=A or B={1,2,3,5,6,7}
239=11101111=(C ⇒ A) or B={0,1,2,3,5,6,7}
241=11110001=(A or B) ⇒ C={0,4,5,6,7}
242=11110010=(A ⇒ B) ⇒ C={1,4,5,6,7}
243=11110011=B ⇒ C={0,1,4,5,6,7}
244=11110100=(B ⇒ A) ⇒ C={2,4,5,6,7}
245=11110101=A ⇒ C={0,2,4,5,6,7}
246=11110110=(A = B) ⇒ C={1,2,4,5,6,7}
247=11110111=(A & B) ⇒ C={0,1,2,4,5,6,7}
248=11111000=(A & B) or C={3,4,5,6,7}
249=11111001=(A = B) or C={0,3,4,5,6,7}
250=11111010=A or C={1,3,4,5,6,7}
251=11111011=(B ⇒ A) or C={0,1,3,4,5,6,7}
252=11111100=B or C={2,3,4,5,6,7}
253=11111101=(A ⇒ B) or C={0,2,3,4,5,6,7}
254=11111110=A or B or C={1,2,3,4,5,6,7}




About the Tutor

Online Tutoring


For Parents

Rate & Contact Info





Online Math Tutor
  • Effective
  • Simple
  • Affordable
  • Expert Tutor
  • Homework Help
  • Exam Preparation
  • All Math Subjects
  • K-4 Through College
  • Individual Online Sessions
  • Excellent Results
  • CSET
  • GRE
  • ELM
  • SAT
  • GMAT
  • TEAS
  • ASTB
  • FBI phase II
  • ACT
  • More...
  • Pass Your Test!
  • Improve Your Grades
  • Get Back On Track
  • Make Math Easier
  • Understand Each Topic
  • Get The Problems Right!
  • Ensure Your Academic Success
Home ~~~~~~~ FAQ ~~~~~~~ About the Tutor ~~~~~~~ Online Tutoring ~~~~~~~ Testimonials ~~~~~~~ For Parents ~~~~~~~ Rate & Contact Info ~~~~~~~ Links

Last review: May 23, 2018

First published: July 31, 2008. © Juan Carlos Castaneda.