Sunday Comix (useless binary logic)
2001-08-07 - 12:30 a.m.
I was going back over some Assembly notes, and discovered this. The following logical argument, based on the logical construction of binary logic, turns out to be completely and utterly useless. Just so you know.
Binary is composed of ones and zeros, called bits. Four bits form a nibble, two nibbles form a byte. In one nibble (a combination of four on/off switches) there are sixteen combinations of distinct possibilities. There are four basic logical devices used to compare binary numbers: AND, OR (inclusive), xOR (exclusive), and NOT. For each of these operators, there is a combination of 1s and 0s that can be grouped together to form a single 1 or 0 for a result. AND, for example, results in a 1 (true) only if both of the two inputted datum are 1 (true); and otherwise results in a 0 (false). Thus:
0 AND 0 -> 0
0 AND 1 -> 0
1 AND 0 -> 0
1 AND 1 -> 1
The operator OR results in a 1 if either of the datum are true.
0 OR 0 -> 0
0 OR 1 -> 1
1 OR 0 -> 1
1 OR 1 -> 1 (or 0, for xOR)
Lastly, the operator NOT needs only one datum and reverses true to false, false to true.
NOT 0 -> 1
NOT 1 -> 0
Now, being the na�ve, bulbous-headed person that I am, I wondered how it could possibly be that there few simple operators can cover all the logical operations that are needed by a sophisticated computer program. Quite simply, there are 16 combinations of results for each operator AND and OR (and the exclusive version of OR). (To make this text simpler, I will call each operator by it�s nibble-name, as AND would be represented by 0001 and OR by 0111) Now, within our 16 possibilities of logical scenarios, at least six combinations are covered, because after the result of AND, OR or xOR is found, it can be runn through the NOT operator to function as it�s inverse of the original function. Therefore, NOT AND would be 1110 and NOT OR would be 1000. And we can also discount the values for 0000 and 1111 in our binary logic theory, because there would never be a use for using an operator in such a case. 1111 would always produce �true� and 0000 would always produce �false�, with no regard to the inputted datum. 8 combinations covered, 8 to go. To create a new logical operator, I paired 0010 and 0100; 0011 and 1100; 0101 and 1010; 1011 and 1101; because each of the elements in these pairs was the NOT-ified form of the other. Looking more closely at 0010, I realized that the operator was none other than GRT, (more commonly known as �greater than�, or >) as seen below:
0 AND 0 -> 0
0 AND 1 -> 0
1 AND 0 -> 1
1 AND 1 -> 0
It follows then, that NOT GRT would be the inverse of LST (also known as �less than�, or <) so 0100 has also been covered by simple operators. The difference (as you might have noticed) between the 0010 and 0010 pair that has just been covered and the 1011 and 1101 pair is the simple switch of 1s on either end of the boolean. This problem is easily covered by the OR statement, or as the function would read in math, => (for 1011), meaning that if the datum is more than or equal to the other datum, the statement is true. The inverse of this function, obviously, is =<. And we can now see the redundancy in the xOR operator, for it serves the same function as mathematical symbol of �not equal�, while NOT xOR functions as an �equal to� operator. This leaves only four logical operations remaining: 0011, 0101, 1010, and 1100. I originally thought, at this point, that my search for a �new land in the Carribean of binary logic� was useless, because the few operators (combined with simple mathematical tools) had sufficiently covered the logical extremities needed for a program, and they would most likely make up for the final four. But this was not the case. Let us look at the fist and second examples, 0011 and 0101.
0 AND 0 -> 0 (0)
0 AND 1 -> 0 (1)
1 AND 0 -> 1 (0)
1 AND 1 -> 0 (1)
Now, it may be possible to get such results through a combination of the basic operators, but it seems much easier to observe the inputted datum as the results. The first example results from the only inputs of the first datum, while the second example results from the state of the second datum alone. And their inverse pairs, of course, can be created from a NOT operator before their operations. But, what operation will give you only the first datum, you ask? There is none, because such an operation would be completely useless, as in the former case of 0000 and 1111. These four last operators would take only one datum and change it into the datum that was originally inputted. Thus, 1 = 1 or 1 xOR 1 NOT, and world keeps turning.
