Computers can do amazing things: play chess, trade stocks, transmit messages across the world. At the lowest level, even the most advanced computer is responding to signals from an electrical current. Logic gates are responsible for determining how those electrical currents combine and diverge. These combinations form the basis for more complicated logic, but it all starts with 1's and 0's.

Learn: Logic Gates

Congratulations! You've built out an impressive array of logic gates. The physical representations of these gates are most likely being used in the computer you're using **right now**!

Logic Gate Review

Good job! You've started with little bits, and you've built out an entire toolkit of logic gates you now can use to perform more complicated operations. You're well on your way to creating an entire operating system. Watch out, Unix!

We've covered:
- Bits and current
- Truth tables
- NAND gates
- NOT gates
- OR gates
- XOR gates

You've done a great job of creating these gates from scratch in Python! All of the basic gates exist already as bitwise operators in Python. Now that you've done the hard work to understand how each works, you can save time by using these built-in operators:

```py
#NOT: 
~ x
#E.g. ~1 == 0 and ~0 == 1

#AND:
x & y
#E.g. 1&1 == 1 and 1&0 == 0

#OR:
x | y
#E.g. 1|1 == 1 and 0|0 == 0

#XOR:
x ^ y
#E.g. 1^1 == 0 and 1^0 == 1
```

Logic Gate Review - Part II

Our first gate is the _NAND gate_. This gate receives two inputs and returns current as long as at least one of the inputs is off.

Here's the truth table:

<div class="narrative-table-container">

|*a*|*b*|output|
|-|-|-|
|0|0|1|
|0|1|1|
|1|0|1|
|1|1|0|

</div>


NAND Gate

Now, we are going to create what's called an _XOR gate_, an exclusive or gate. This gate receives two inputs, `a` and `b`, and only returns a `1` if one of the inputs is `1`, but not if both of the inputs are `1`.

To build your `XOR_gate()`, you should use any combination of the gates you've already made: `NAND_gate()`, `NOT_gate()`, `AND_gate()`, and `OR_gate()`.

Here's the truth table:

<div class="narrative-table-container">

| a | b |output|
|-|-|-|
|0|0|0|
|0|1|1|
|1|0|1|
|1|1|0|

</div>

XOR Gate

Our next gate is the _AND gate_. This gate receives two inputs and only returns current if the inputs are both *on*.

As in previous exercises, you'll only be able to use gates you've previously built: `NAND_gate()`, and `NOT_gate()`.

Here's the truth table:

<div class="narrative-table-container">

|*a*|*b*|output|
|-|-|-|
|0|0|0|
|0|1|0|
|1|0|0|
|1|1|1|

</div>

AND Gate

Now that we've completed our `NAND_gate()`, we can use that function to build other gates.

This time you're starting from scratch, so lean on that truth table. Fortunately, our next gate, _NOT_ only has one input.

Here's the truth table:

<div class="narrative-table-container">

| **a** | output |
|-|-|
|0|1|
|1|0|

</div>

NOT Gate

Logic gates have certain rules that determine what the outputs are with respect to the inputs `a` and `b`. When we are analyzing a logic gate, we can visualize all of the possible outputs by making a _truth table_. A truth table shows the output for all possible inputs.

For example, if we have a gate that returns `1` if and only if both the inputs `a` and `b` are `1`, we can create the truth table: 

<div class="narrative-table-container">

|*a*|*b*|output|
|-|-|-|
|0|0|0|
|0|1|0|
|1|0|0|
|1|1|1|

</div>

Each row represents an observation of output depending on the values of `a` and `b`. So the first row shows that when `a` is `0` and `b` is `0`, the output will be `0`. 

When we make a truth table, we want to represent the entire universe of possibilities. This means that we want every combination of inputs to be represented. For 2 variables (`a` and `b`), we will need 4 rows to represent all of these combinations.

In Python, and many other programming languages, `1` evaluates to be `True`, and `0` evaluates to be false.

Truth Tables

The next gate we are going to build is the _OR gate_. This gate receives two inputs and returns `1` if either one of the inputs is `1`.

To build your `OR_gate()`, you should use any combination of the gates you've already made: `NAND_gate()`, `NOT_gate()`, and `AND_gate()`.

Here's the truth table:

<div class="narrative-table-container">

| **a** | **b** | output |
| - | - | - |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |

</div>

OR Gate

Computers are capable of dizzying feats, but they're built from humble origins. At the lowest level, computers run on electric currents limited to two states: power or no power.

There are many ways to represent the two states:

* "I have current!" vs. "I don't have current!"
* "on" vs. "off"
* `+` vs. `-`
* `True` vs. `False`
* `1` vs. `0`

We'll use `1` and `0` for the remainder of the lesson. This piece of information (power or no power) localized to a single location is called a _bit_. 

* Bit with power: `1`
* Bit without power: `0`

_Logic gates_ receive one or more inputs of current and alter the power according to their rules. 

Some logic gates will only output power if both of their inputs are powered:

```py
logic_gate(1, 1)
# 1
logic_gate(0, 1)
# 0
logic_gate(1, 0)
# 0
logic_gate(0, 0)
# 0
```
Other logic gates output power if either of the inputs are powered:
```py
logic_gate(1, 1)
# 1
logic_gate(0, 1)
# 1
logic_gate(1, 0)
# 1
logic_gate(0, 0)
# 0
```