Introduction
Modern computers are constructed using digital logic circuits which allow linear analog electronic components like transistors and resistors to emulate boolean logic functions. The fundamental unit of a digital logic circuit is called a gate and all digital circuitry is built by interconnecting various gates.

Every basic gate has two inputs and one output, each of which can be in a high or low state ( i.e. voltage ). Each gate is defined by its truth table which is a list of outputs for each set of possible inputs. One exception is the NOT gate which has one input and one output.
If we represent a high state by one and a low state by zero, The possible inputs to a gate are 00, 01, 10, and 11. In the intersests of brevity, we can represent a gate by the output it produces for each of these inputs respectively.

The possible logical gates (which have names) are:
```AND  - 0001
OR   - 0111
NAND - 1110 (Not AND)
NOR  - 1000 (Not OR)
XOR  - 0110 (Exclusive OR)
XNOR - 1001 (Not Excusive OR)
IMP  - 1101 (Logical implication)
NOT  - Outputs the inverse of its input.
```
It is provable ( and obvious ) that any set of outputs can be generated by a combination of AND, OR and NOT gates, or by a combination of NAND gates alone.

Boolean logic representation of arithmetic operations:
To perform arithmetic operations, the binary representations of the numbers involved is processed by an array of gates.
For example, the operation of adding two binary digits has two inputs and two ouputs, with the following truth table.
The outputs are the sum and carry bits (S and C )
```          _______
_______ | A + B |
| A | B || S | C |
|---|---||---|---|
| 0 | 0 || 0 | 0 |
| 0 | 1 || 1 | 0 |
| 1 | 0 || 1 | 0 |
| 1 | 1 || 0 | 1 |
----------------   ```
It is clear that the sum bit is A XOR B and the carry bit A AND B.
A circuit consisting of an AND gate and XOR gate with their inputs wired in parallel thus adds binary digits together and is called a half adder. Similarly, all arithmetic operations can be carried out by manipulating the bits using logic gates.

Now we are ready for :-

Arithmetic representation of boolean logic
While idly pondering the above (Boolean logic representation of arithmetic operations) , I realized that the converse was also possible.
If we restrict our inputs to 1 and 0, we have:
```A AND B = A * B
A OR B  = A + B - ( A * B )
A XOR B = A + B - ( 2 * A * B )
NOT A   = 1 - A
```
In C++ code you could write:
```bool AndFn( bool a, bool b ) { return bool( int(a) * int(b) ); }
bool OrFn( bool a, bool b ) { return bool( int(a) + int(b) - int(a) * int(b) ); }
bool XorFn( bool a, bool b ) { return bool( int(a) + int(b) - 2 * int(a) * int(b) ); }
bool NotFn( bool a ) { return bool( 1 - int(a) ); }
```
So it is possible to represent any boolean expression as an arithmetic one.