- Blackout
- Faster Than Light
- Hex Board
- Invariants
- Listening To OEIS
- Logic Gates
- Penrose Maze
- Syntactic Sugar
- Terminal Colors

- Traffic Engineering with Portals, Part II
- Traffic Engineering with Portals
- Algebra and Data Types
- What's a Confidence Interval?

- Hilbert's Curve
- Preventing Log4j with Capabilities
- Traffic Engineering with Portals, Part II
- Traffic Engineering with Portals
- Algebra and Data Types
- What's a Confidence Interval?
- Uncalibrated quantum experiments act clasically
- Pixel to Hex
- Linear vs Binary Search
- There and Back Again
- Tree Editor Survey
- Rust Quick Reference
- The Prisoners' Lightbulb
- Notes on Concurrency
- It's a blog now!

I trust that you have heard that nand gates are universal, meaning loosely that with enough nand gates you can construct any other binary gate. But can we define this more precisely? And other other gates universal?

A binary gate takes two inputs, each of which is either 0 or 1, and
produces an output of 0 or 1. There are 4 possible input combinations,
so there are 2^4 = 16 possible gates. You can *combine* three gates x,
y, and z by applying z to the outputs of x and y.

A set of gates is *closed* if no combination of those gates can
produce a gate not in the set. Clearly the empty set of gates is
closed, because you can’t form any combinations at all. And the
complete set of 16 gates is closed because any gate you form from them
is clearly in the set. So is the set containing just the ‘true’ gate
that always returns 1 regardless of its inputs. In general, it’s easy
to check whether a set of gates is closed: just consider every
combination of three of them and check that it’s still in the set.

Now we are ready to talk about *universal* sets. As we said before, a
set of gates is universal if every other gate can be built from some
combination of its elements. But how can we compute this? One
possibility would be to consider every combination of three gates in
the set in turn, check if that adds a new gate and if so add it to the
set and start again, and stop once we’ve made a complete pass without
discovering any new gate. This is called a *fixpoint* algorithm. But
in this case it would be very slow. How can we make it faster?

There’s a neat insight here, which is that

A set of gates is universal if and only if its smallest closed superset is the complete set.

Convince yourself of this fun fact :-). We can use it to greatly speed
up testing if a set of gates `S`

is universal by precomputing all
closed sets of gates (of which there are only a couple dozen), and
then simply checking which closed sets `S`

is a subset of.

Finally, here is a listing of all of the closed and universal sets of gates (using the above trick) given a set of “assumed” starting gates. If you assume no starting gates (other than the “identity” gates representing the two inputs), there are only two singleton universal sets: nand and nor. But there are more if you allow a “false” gate which always outputs 0, or a “true” gate which always outputs 1!

*** NO GATES *** Closed Sets: false true false true not false true not and false and true and false true and false and nimp true eq or false or true or false true or true or imp and or false and or true and or false true and or true and or eq imp false xor false true xor eq not false and or xor nimp Minimal Universal Sets: nand false imp not imp nor true nimp not nimp imp nimp and not eq nimp false and eq or not false or eq xor imp true and xor and xor eq true or xor or xor eq *** FALSE GATE *** Closed Sets: true true not and true and and nimp or true or and or true and or xor true xor eq not and or xor nimp Minimal Universal Sets: nand imp nor true nimp not nimp and not eq nimp and eq or not or eq true and xor true or xor *** TRUE and FALSE GATES *** Closed Sets: not and or and or xor eq not Minimal Universal Sets: nand imp nor nimp and eq and not or eq or not and xor or xor

And here is the python script which generates it:

```
class Gate:
def __init__(self, name, arrays):
self.name = name
self.array = arrays[0]
self.arrays = arrays
def __str__(self):
return self.name
def __repr__(self):
return self.name
def __getitem__(self, index):
return self.array[index]
def apply(self, x, y):
return applyGate(self.array, x, y)
def applyGate(array, x, y):
return array[2 * x + y]
def combine(gate1, gate2, gate3):
array = (applyGate(gate1, gate2[0], gate3[0]),
applyGate(gate1, gate2[1], gate3[1]),
applyGate(gate1, gate2[2], gate3[2]),
applyGate(gate1, gate2[3], gate3[3]))
return gateTable[array]
g_id = Gate("id", [(0, 0, 1, 1), (0, 1, 0, 1)])
g_false = Gate("false", [(0, 0, 0, 0)])
g_true = Gate("true", [(1, 1, 1, 1)])
g_not = Gate("not", [(1, 1, 0, 0), (1, 0, 1, 0)])
g_imp = Gate("imp", [(1, 1, 0, 1), (1, 0, 1, 1)])
g_nimp = Gate("nimp", [(0, 0, 1, 0), (0, 1, 0, 0)])
g_and = Gate("and", [(0, 0, 0, 1)])
g_or = Gate("or", [(0, 1, 1, 1)])
g_xor = Gate("xor", [(0, 1, 1, 0)])
g_eq = Gate("eq", [(1, 0, 0, 1)])
g_nand = Gate("nand", [(1, 0, 0, 0)])
g_nor = Gate("nor", [(1, 1, 1, 0)])
allGates = [g_id, g_false, g_true, g_and, g_or, g_xor, g_eq,
g_not, g_imp, g_nimp, g_nand, g_nor]
gateTable = dict()
for gate in allGates:
for array in gate.arrays:
gateTable[array] = gate
def printGates(gates, freeGates):
for gate in allGates:
if gate in gates and gate not in freeGates:
print gate,
print ''
def closed(gateSet):
"""A set of gates is closed if no other gates can be formed from
it by combination."""
for g1 in gateSet:
for g2 in gateSet:
for g3 in gateSet:
for a1 in g1.arrays:
for a2 in g2.arrays:
for a3 in g3.arrays:
if combine(a1, a2, a3) not in gateSet:
return False
return True
def universal(gateSet, closedSets):
"""A set of gates is universal if all other gates can be formed
from it by composition. This is true iff its smallest closed
superset is the complete set."""
for set in closedSets:
if set.issuperset(gateSet):
return False
return True
def minimal(S, universe):
for set in universe:
if set < S:
return False
return True
def powerset(S):
subsets = []
for n in range(2 ** len(S)):
subset = set()
for i in range(len(S)):
if n / (2 ** i) % 2 != 0:
subset.add(S[i])
subsets.append(subset)
return subsets
def findAllGateSets(freeGates):
gateSets = []
for gates in powerset(list(set(allGates) - set(freeGates))):
gates.update(freeGates)
gateSets.append(gates)
return gateSets
def main(freeGates):
allGateSets = []
closedGateSets = []
universalGateSets = []
minimalUniversalGateSets = []
allGateSets = findAllGateSets(freeGates)
print "\nClosed Sets:"
for gates in allGateSets:
if (closed(gates) and len(gates) != len(allGates)
and len(gates) > len(freeGates)):
printGates(gates, freeGates)
closedGateSets.append(gates)
for gates in allGateSets:
if universal(gates, closedGateSets):
universalGateSets.append(gates)
print "\nMinimal Universal Sets:"
for gates in universalGateSets:
if minimal(gates, universalGateSets):
printGates(gates, freeGates)
minimalUniversalGateSets.append(gates)
print '*** NO GATES ***'
main([g_id])
print '\n\n*** FALSE GATE ***'
main([g_id, g_false])
print '\n\n*** TRUE and FALSE GATES ***'
main([g_id, g_true, g_false])
```