## Neat idea

I have exactly zero doubt this has already been done. I’m probably cribbing from stuff I’ve learned and then forgot.

First, an idea I know is pretty widespread: networks can be represented as binary matrices. If we have three objects A, B, and C that are either connected or not connected, then these connections can be represented as 0 (not connected) or 1 (connected).

[1, 1, 0; 1, 1, 0; 0, 0, 1]

So anything that’s in slot A is connected to itself and the thing in slot B, ditto for B, and the thing in slot C is only connected to itself. That’s a network of connections on a breadboard sans any semantic meaning. Using matrix multiplication, we can plug stuff into the slots A, B, and C back and give the merely formal network some “qualia” or data:

[A, B, C] [1, 1, 0; 1, 1, 0; 0, 0, 1]

So maybe thing A is a computer, and thing B is the monitor, and thing C is a printer. You boot the computer and stuff shows up on the screen, but when you try to print something it doesn’t work because C isn’t connected to anything.

I should mention that all of these wires are thought of as unidirectional. Each semantic box (A, B, C) has input and output. So if C is plugged into itself, that means there’s a wire going from an output jack of C to one of C’s input jacks.

Okay, time for a weirdo example. Here’s an R-S latch:

There are two data inputs (S and R) and two NAND logic gates (call the top Ed and the bottom Ted). Therefore we have an object vector like so: [S, R, Ed, Ted], and a system like so:

S is only connected to Ed: [0, 0, 1, 0]
R is only connected to Ted: [0, 0, 0, 1]
Ed is only connected to Ted: [0, 0, 0, 1]
Ted is only connected to Ed: [0, 0, 1, 0]

Yielding a system like so:

[S, R, Ed, Ted]

[0, 0, 1, 0]
[0, 0, 0, 1]
[0, 0, 0, 1]
[0, 0, 1, 0]

I want to figure out whether I can express an algorithm by adding another vector to the system that gives the “rules of behavior” for S, R, Ed, and Ted.

Edit: Should make this explicit. The idea I’m getting around to eventually is that it seems to be possible to reduce the formal description of any electronic computer to a couple of very large binary numbers.