Patch

As a system of coordinated action, capitalism has strengths and unstrengths. For example, take the early success of Warren Buffet, glistering icon of dedication and good business. Very young, he decided he was going to be rich. Then he followed through, learning how it's done wherever he could. By 16, he'd saved up $5,000, which in today's terms is more like $60,000. If he could do it, why can't everyone?

In a predominantly capitalist system, much of something could get in the way that isn't fair at all. What if you have an illness that's very expensive to treat? Now your growth (or "growth," if you are a skeptic) as a citizen is impeded not only by the afflictions of the disease, but also by the afflictions of poverty and missed access. If it takes money to make money, and your funds are all absorbed away by something you can't control, then losing money means you lose even more money, and with it, chances for success, and with those, your potential to contribute to society.

Surely that isn't optimal. Most of us in my generation, and perhaps a vast majority around the world, agree this is not optimal. Not optimal, you might say, but it's the fairest system we have that works. And you aren't right if you say that. It's already quite apparent that mixed economies, when set up wisely, work as well as or better than purely capitalist economies.

If imperfect capitalism works better than capitalism, then capitalism isn't the best system. If capitalism isn't the best system, it seems likely that imperfect capitalism isn't the best system, either. Where do we go from here?

Capitalism drives cooperation by competition and competition by cooperation. When the same rules apply to everyone—a tenet of free enterprise—then on one level, the system of rules is fair. Yet anyone who has played a board game knows that applying the same rules to everyone doesn't guarantee playability, balance, or even fairness itself. And everyone who has followed a high-profile court case knows that, at least in the United States of 2019, the rules do not apply equally to everyone.

How can we keep (and improve) the cooperative, competitive, resource-managing, and motivating features of capitalism without succumbing to its many catalogued ills? If the server of the state has a bug, what is that bug, and how do we fix it?

Which if?

We earthlings don't like uncertainty. We usually like imagination. My suggestion: rather than depend on a show of confidence, which ultimately is rather empty or illusory, to get attention and credibility where there's real uncertainty, use imagination.

Rather than say, "We just can't draw a firm conclusion based on these numbers and this proposed mechanism," you can suggest alternative explanations that could hold water for all we know. A vivid alternative can appear positive where a statement of uncertainty would appear negative, even though they are basically the same. As a culture, we ought to embrace uncertainty more as the critical spice it is. Until then, though, use imagination?!

Plicō, plicāre

Is the cat in the box alive or dead? I have the simplest solution to the paradox. The cat makes decisions.

Free will is part of the universe's drive toward entropy. When I was in high school it didn't make sense, as it doesn't, logically, by most any analysis. But now I think it makes a shadow of a sliver of a sense of sense.

Consciousness is not an illusion. If it's an illusion, who is being fooled?

What does it mean to fool an agent without original agency? Why would this entity need to be fooled to prove to it that it isn't what it isn't? By the subjective experience of consciousness and will, which must have evolved as a capacity and must exist in physics as a phenomenon, the universe gives us the means to avoid realizing the truth, which is that this subjective experience is false and we are glorified pinball machines. Why create a subjectivity only to fool it, when there needn't have been a subjectivity at all? And why did consciousness and the experience of active will evolve before any conception of determinism, as would seem extremely likely, given the apparent consciousness of animals?

That doesn't make any sense either, you know.

Let's assume that we are all computer code, and that the code crashes when it looks at itself and realizes that it's deterministic. If it's deterministic, then it doesn't have to do anything; it can just wait for fate to move it. Let's say that logical moment crashes the code, much like dividing by zero. Ok. Ok? The simplest solution here is to evolve ways to keep the code out of that pitfall. You don't need consciousness and an illusive feeling of free will for that. You don't need any feeling of feeling at all. You can just go right on running the code, with the modification that it isn't allowed to divide by zero—or become omphaloskeptic enough to falter.

The illusion of free will is an unnecessary solution.

Across and Opposite of Barrier

The other day I was thinking again about Marshall McLuhan's "The medium is the message" after reading a really good article on the birth of information theory. And I believe I understand the metaphor, but it's easy to misunderstand. At the risk of kneading the obvious, here we go...

Just to pluck up a stray petri dish of an example, the first new Star Wars came out, and (who, me?) I loved it. The Force Awakens! My one big complaint wasn't that it rehashed old plot-liner (very close to a reboot of A New Hope), because I felt that fit. It's a trilogy of trilogies. There will be some recapitulation, otherwise it'll become too amorphous. A poem has stanzas; Star Wars now has a reboot built in.

No, I found the movie thrilling. And this redundancy aspect was a statement, too. New makers, same spirit. If a lot was the same, a lot was different. Anyway, that wasn't my complaint. Nor was the deus ex machina of the Millennium Falcon appearing early on. That said something like, "Ha, gotcha. You didn't realize the Millennium Falcon was part of the Force, did you? It is. Fate will not explain itself to you always." The plot hole improved the experience in meta. No, my biggest complaint was that certain little moments had become de rigueur. When the trilogy of trilogies was first outlined, did Mr. Lucas have any idea how many scenes would involve a Jedi (or Jedi to be) in a fight, arm outstretched, verging on vanquished, light saber pathetically far off, wobbling? It wasn't story parallels or special effects or the unexplainable, but these little tics that were now shopworn. You aren't rehashing old story when things like this happen. You're... a genre.

And that's what resolved the irritation for me. I read another interview with the guy who wrote the script with the director, and he talked very openly about the work of writing genre stories. He'd decided that Star Wars was a genre, and he was thinking about it in exactly those terms. Ah, I thought. Ok. That was intentional.

The next thing he said was what was most interesting. He said that genre doesn't tell you what story to tell. It doesn't tell you what your theme is, your point, your message. You can write a strict genre movie (book, song, etc) about absolutely anything. And that's the beauty of genre. It's like the form of a poem. A sonnet could be about anything you want.

In other words, the medium isn't the message. Right?

It is a metaphor. Your eyes are not two shining suns. Your eyes are biological material with lenses and photoreceptors.

And this unrolls tendrils especially when you think in Claude Shannon terms about what a medium actually is. A medium is something like a sheet of paper. Papyrus is one medium, vellum another, tapestry another, woodcut another, flattened and bound wood pulp another—all closely related. Sure, a sheet of paper could suggest all kinds of ideas to you, and there are ways you cannot repurpose a sheet of paper. But there is so much you can represent on or with a sheet of paper that you are almost unconstrained. The sheet is genre. You can make it about anything you want.

It's worth agreeing that medium, genre, series, form, and format are different ideas. But this actually feeds into the larger claim. If genre allows just about any message, then medium certainly does. McLuhan is right, of course: choice of medium (and genre, series, form, format, etc) is part of the message and imbues it. And the appearance of a new medium changes society, revealing natural hierarchies and possibilities previously unknown. But we also need to agree that all these nouns work as information channels in the brass tacks mathematical sense outlined by Claude Shannon. Genre—say "historical fiction" or "dubstep" or "televised golf"—is like a wire. It's a narrower wire than medium—say "podcast" or "magazine" or "plasticine."** But they're both wire-like, media, tubes of aether. And both work just like wires to carry what wouldn't be there otherwise, which brings options to sender and receiver.

**If you want to call these more expansive names like "recorded sound" and "print" and "sculpture," then so much the better. That strengthens the argument.

Expression

For all that new tech gets old, computing is universal. It doesn't turn into a raisin and then topsoil. It's here to stay past the morning. It always was here, but in the last century, humanity has discovered the informational equivalent of electricity. And that isn't "big." That's got more unseen matter than a galaxy cluster.

It's the same thing I like about early, silent movies and improvisational music. There's this aura of elemental invention. The silent movie makers are more limited, more hobbled than anyone who came after them, technically. Yet they know anything is possible. They'll do weird things like try an entire feature-length film with characters but no words, and more amazingly, it'll succeed even by today's narrative standards. They'll slap a color on the projector in the cinema to show you, ponderously, that it's daytime, evening, or nighttime, despite black & white footage. They'll have a person walk into the theater, sit down at a piano, and make up music while watching the film with you.

This is crazy shit. None of it's realistic. Even the acting is wildly unrealistic. Most people find it unbearably hammy. But given these films had no sound, the visual acting had to carry what was missing. This was a functional adaptation. They could have thrown out their hitchhiking towel and said, well, guys and girls, we just can't put on a performance like the one next door they're doing with Agatha Christie's play, so what's the point? They could have gone home. But they believed anything was possible, and so you have silent films with the whole range of acting from subtle to ridiculous, and even at the most unbelievable end, the ridiculousness is often helping to convey the message, and it becomes part of the aesthetic, like the unrealism of claymation.

I don't know how to convey that sense to others. Maybe it's something I gravitate to, and I can't convey it.

Sit down, or stand up, with any musical instrument or soup can, and make music. You don't need to be a musician. Make music. Explore the possibilities of sound.

We think a person needs to earn the right to speak freely. Before you're allowed to paint what you want, you'd better paint what your teacher asks.

And I think that's antithetical (as an attitude) to discovering the possibilities of paint. Oh right, yes of course, you can paint what your teacher wants. That's fine. And you'll learn something. I'm an educator and believe in education. But what I'm saying above is what possibility and creation are about.

Maybe I have no idea what I'm talking about, or this is just garden-variety ego (who am I to talk about this anyway?), or I'm expressing a feeling and pretending it's logical when it's a feeling.

Computers allow us to explore choice in a way that has never been possible before.

Computing isn't just an aid to this or that. Computing is a medium—perhaps the greatest medium aside from the physical universe and the stuff of our minds—of choice.

Information is defined in several key ways: an alphabet soup of symbols, probability, choice, surprise.

It's often said that quantum mechanics is an ad hoc set of equations cobbled together from experimental evidence. It's said so often it's become an old chestnut. But since 2001, several theorists have shown that you can "rediscover" quantum mechanics from a few axioms (rules), usually just two or three, having to do with information and its properties. The key notion I took away from that article is that quantum mechanics, while it seems forbidding and weird, is actually just a generalization of probability theory. It's a mathematical structure that happens to mirror what's going on all around us laceratingly more closely than we would have any right to expect.

Quantum mechanics is also about choice. And it's also computational.

Isn't this exciting? To me, it's exciting... it's maybe the most exciting thing going, and I wish I knew a better way to express that.

1-0

Every process we know can be boiled down to data and transformation (which can be represented as data), and once you allow the transformation-and-data to work on itself, you have the core of a processor that can do anything known.

Feedback. Iteration. Recursion. Growth.

This process can even create and split dimensions. See infinity categories. See fractal geometry, geometry that results from these feedback (growth) processes, points and lines and planes branching out to cover more dimensions than just their own. A fractal is a pattern with fractional dimension: it's somewhere between one solid number and another solid number of dimensions. It's 2.473D, or similarly not a whole number. It's stuck growing, what you get in between the one and the other.

If "stuck growing" isn't demented or plain wrong, it sounds a little like time...

When people talk about "seeing into the matrix," that isn't a bad analogy. A matrix is an excellent example of data and process in one bucket. A matrix can be seen as a data dump. It can also be seen as a thing you multiply by in order to change a system. And we already know this idea: code is data (1s and 0s) and it does work (changes 1s and 0s). 1s and 0s aren't just practical icons or a false dilemma. Almost a century ago, it was shown mathematically that 1s and 0s can do everything that 0-9 can do, and moreover can do everything math symbols and any information can do. That's heavy simplicity. It was shown shortly afterwards that this applies just the same with quantum mechanics and non-deterministic systems. Amazing when you think about it? Your experience of thinking and feeling could be representable as 1s and 0s, even if the world isn't deterministic.

Information, in fact, is defined most basically as "surprise." If you fully expect it, it doesn't surprise you and isn't informative. If it isn't what you expect, you're surprised and may learn something. Information. It's a measurable quantity, not just subjective. I would even argue that information, surprise, the feeling that we didn't expect this, is the best proof we have that the outside world and other people exist. We often say it can't be proven logically that the outside world of objectivity exists, we have to take it on faith, and maybe so. But for me, surprise works. If I'm surprised, I definitely didn't come up with it all myself in this moment. Information tells me there is reality outside my present self. And if there is reality outside my present self, there is reality outside myself.

Multiplying by a matrix doesn't do everything that the process up top does. The real "matrix" is both more than and less than a matrix. Simpler but harder to understand.

For all that laptops/phones/etc are elaborate devices that no one person fully understands anymore (really truly, and I think this should still be kind of shocking even when you "know" it), this piece inside, what you do with the 1s and 0s, is amazingly powerful and elegant. It's complex in the best sense: simple yet intriguingly very difficult to fully wrap your head around. And that isn't because you aren't smart. It's because it's mathematically proven impossible to fully wrap your head around it. Just like we can't write out π in a finite number of digits. And, similarly, like mathematics tells us we can't predict the weather for long: we have a brief window of decent approximation (2 days currently), and beyond that, our best calculations (and the best possible calculations) rapidly get far worse. It will still be true with quantum computers, and our brains aren't besting this either. We expect our AI to surpass our intelligence in all areas eventually, but not to predict the weather much better. Barring a colossal shift, we will never be able to predict the weather in a year well, unless the weather transforms to something else, something like very still water, a frozen atmosphere. This isn't because our algorithms, processors, programmers, or meteorologists suck. It's because, well, math. The chaos mathematician in Jurassic Park explained it: you can't predict which way the water drop will go.

If we knew all that first paragraph above meant, I don't think we'd need the universe or evolution or our lives to find out. We're here because it can't be fully known to anyone what that process will be like in advance. It has infinitely many potentials, infinities of infinities. We are just a few of the experiments that result.

Obviously there are unknown unknowns and this could all be tossed into turmoil by some new discovery. (Information. That would mean the outside world exists ;) But we already knew that.) And the idea I started with here probably covers more than any of us appreciate. It covers anything we can simulate, much of which we won't be able to follow ourselves. It covers all known laws of physics and science. It's a lot. And maybe I haven't phrased it well or perfectly, but I'm trying to share what I hope I do understand at least a little. The basic thing above is the insight I got from an assignment long ago simulating a simplified CPU in C code. It was a great assignment, and I was very lucky and privileged to be given it. The insight I thought I got from it was in fact the intended point, what the assignment was supposed to teach, but it took me years to fully realize that. And that's the first paragraph. It's what all computers, computation, and known processes can be boiled down to: data, structure, and process are one. Or at least they can be interconverted by energy in an instant. That's what a CPU is. It converts these things into each other instantly when powered with electricity. And when that idea swirls in on itself, when there's feedback (like microphone feedback) that results in some kind of growth or regulation process (think of the piercing high pitch from the speakers which nevertheless levels out at a certain painful volume), which it can in a CPU, you get Frankenstein lightning, or something a lot like it.

That's why Lisp, a programming language invented in the early 1960s, is still trendy (in its many modern dialects). It's the language that most clearly depends on and exposes this "simple" aspect of all computation. Is it the best language to write an app in? Maybe, maybe not. Probably not, to be honest, though it'll work and some people prefer this way (and Clojure in particular gives you access to everything that has been built in Java, easily, from within the language, so it's very viable currently). Even the AI crowd have kind of given up on the vision that immersing themselves in this level of purism will help them create a sentient being or something. An entire commercial operating system popular with AI researchers in the 70s-90s (Genera, aka the Lisp Machine) was built in and for this language that constantly shows you how data and process are one. You can't write a single line of Lisp code without staring at that. The system functioned and still does. It does everything any computer can do. Just because a thing is true doesn't mean it'll show you the next step on your path. But will it teach you something? Yes.

What maybe amazes me most is that such a simple idea can also handle non-determinism. When we say "every process is computational," we are not necessarily saying "every process is deterministic."

Do I understand what I just said? Not really.

But my core interest is in choice. Games are the art form of and about choice. That's what got me into the idea. What is choice? What is will? Does a choice mean anything out of context? (In my opinion: no.) How does context affect choice? Where does an element of choice that does not come from context come from? And so on. These are interesting questions when you want to communicate with choice as a central idea. Everything we say or do involves choice. Even everything we sense hints at choice. It's what we are. So what is it?

If the universe only went one way, I personally don't believe I'd have any business being here and going through with this. In my opinion, my presence does something other than give one of the characters in a movie their own predefined internal dreams which are actually felt. The actually-feeling is somehow instrumental. It's necessary. It has to be here. It does something. For every force, there is an equal and opposite force. The universe applies all these experiences to me. That's imposed on me. I cannot escape experiencing, and most of what I experience follows all the regular laws of physics. So what's my role? What is the equal and opposite force? Does the entire universe outside me feel in some way comparably to me? If this is going to be equal and opposite, and the universe is so much bigger, then where is the balance? What do I have that the universe doesn't? How are we equally matched?

The universe informs me: gives me a signal, one from many possibilities. And I inform it: give a signal back, one from many possibilities.

Maybe Newton's equal-and-opposite idea doesn't apply to everything. Maybe this is in no way equal or opposite. And maybe I'm predetermined, a spectator, a seat in a rollercoaster moving, allowed to feel but not to change the path.

And I use Pascal's Wager on that. If so, then whatever my opinion is, it's the opinion I was always going to have at this moment. And so I haven't done anything wrong, couldn't have done any differently. In this case, there is nothing I can lose by adopting the wrong opinion that I wouldn't have lost anyway (by adopting the same wrong opinion). If this is the correct view, the total risk of making a mistake versus any other possibility I'm considering adds up to: 0. There's only one path.

On the other hand, if this is not all mapped out in advance, if there are choices given to me, if I can reach different endings from here, and by different paths, then I stand to lose everything I could possibly lose by ignoring that reality.

Pascal's Wager was originally applied to God and the Devil and Heaven and Hell and belief and doubt. In that context, I do not believe it works. There are a number of criticisms, including that you could alter the form of the reward/threat to pretty much whatever you want, and thereby get people to do whatever you want. It ends up being a bad argument that doesn't work as intended.

However, I believe the use of the same basic structure of an argument in this case does work. It isn't that I know I have free will, or that I know the world is non-deterministic. It's that there is everything to gain from making the bet that it is, everything to lose from mistakenly declining it, and nothing to gain or lose from making the other bet if it does win the day. So unlike Pascal's original wager, it doesn't take the form of a threat, a carrot and stick that could be tweaked to manipulate. It's just point-blank reason.

Quoting lambs or is that lambda

There's this assignment I did in high school. We simulated/emulated a computer processor chip, a CPU, by writing C code to do exactly what every part of it did on the level of individual 1s and 0s. The processor wasn't real. It was the "MIC-1," a fictional chip that has never been produced. But it was real in the sense that the design worked the same way. It could have been produced. It was just too simple to be worth producing commercially. An exercise. But that exercise may have taught me more than any other assignment in high school.

It taught me how binary numbers do work on a chip, how they move things around. How they combine and juggle information. How the operations and the data worked on are both strings of 1s and 0s, and how that makes sense. Structure and movement are one. Data and calculation are one. Both actions and things acted upon and moved are just ons and offs. Switches. It was like directing the flow of water around a maze... with water... down forking river-railroads, like a splitting train. A branching ferry of water-electricity 1s and 0s. The shape of the maze at each moment was what it did in that moment. Its final answer now could be its shape later.

There were two other lessons. First (or second of three, really), I completed the assignment, but I never got full credit for it. Right as I was getting ready to turn it in, very happy and proud that it was working, I made a mistake on the command line and overwrote my source code. I put ">" instead of "<". If you've used Unix much you know what I mean. There was no recycle bin to save me there. I lost it and had to go back to a very old version, and scramble to make it semi-acceptable. I don't believe I've ever repeated that mistake. And I've lost almost no data in my life unintentionally. And I tie this to chance. The only big example that comes to mind was when my hard drive was destroyed by an EMP from a freak electrical surge from a distant lightning strike which caused an electrical fire in and under the building. My laptop was unplugged, but the pulse through the air killed my hard drive. And I only lost a small fraction of files that were in a folder that wasn't backed up. I have very often not lost my data, and I've always reminded myself that this is mainly because I'm lucky, not because I'm smart or doing everything right. There is a key truth. Knowing what luck is by now has been a big reason my data loss hasn't been much worse, but also luck is a big factor itself. This lesson here with my code helped, and I think anxiety helps. It's similar with driving. I'm still alive because of luck: or, rather, largely unexplainable probability so far. But I'm much worse at driving than at saving data, so that's a reason I want to segue to walking and public transit again, sometime soon. (I know, I seem to be rambling, but these things are truly connected and I could elaborate the connections more but will leave them to your imagination.)

The third lesson was the best. Right at the end, when I was finalizing the code that I was about to destroy, something happened. All of the code came together in one line. One line of code tied the entire virtual processor together, all the little pieces, the shifting channels of information, the storage and retrieval from registers and from the slower memory of RAM, the arithmetic operations, the comparisons between two things. Everything occurred, finally, in one line. That was the moment. It was so dumbfoundingly simple that I felt this had to be the main insight of the entire assignment. While I wasn't sure, I had that moment anyway: almost a eureka moment. And it worked. The chip functioned, I fixed a couple little issues, and a few minutes later I'd deleted it all by mistake.

Wasn't this realization, this "simplification" or "big picture" just coming from writing C code, code written to be easier for humans to understand than 1s and 0s and transistors and registers? Was it just how I had written the thing, and someone else could have written it differently? Was it a real insight, or just a cute line of code, a long string of the function of the function of the function of the function of the function of... It was pretty long, but the entire line was just function composition. Maybe I'd just written it that way, or I'd been encouraged to write it that way by the outline of the assignment. Maybe it didn't really mean anything.

And the funny thing is, it's taken 20 years for me to realize, for certain, that yes, this was absolutely a core insight about all computers. And not just all computers, but all physical processes in general. It can all be seen as function composition. I hesitate to go into detail on this, because I don't even know where to begin and I barely know what I'm saying myself, but if you do want to know, go and read about Alonzo Church's lambda calculus. It's... exactly what I saw a few moments (maybe an hour, actually; I think I'm embellishing and shortening that part, but hey I'm telling you) before I deleted that code. And it wasn't a coincidence or how I happened to have organized my code. No, it was the nature of all computers in the world, and all the computers and physical processes that are theoretically possible.

That's a pretty good assignment, huh?

And so I should have known. There have been many opportunities to make the connection, and I did. Somewhat. Partially. I thought I got it. For example, there's Lisp and the whole "functional programming" movement. But it was only the other day that the whole ton of bricks fell on me. Yes, no, yes, that was in no way a coincidence. The power of the parenthesis. It was even bigger than I imagined.

The class was called Computer Architecture, and it was taught by a middle-aged, overweight woman who was unassuming but sharp as a razor. She made a passing reference to all those function compositions afterwards, so I had one lead that it actually was important. But she left it to our imaginations and our curiosities to find out.

The best lesson is finding out, but I'll try to put it into normal words.

It goes back to algebra and functions. You send a number in, you get a number out. Right?

So f(x) = x*x becomes 36 when x = 6. If there's always just one number coming out (36), not indecision about two or three or four numbers that could be the answer, if it's always just one number coming out, then that's a function. That's basic determinism. And it's basic calculation.

And when you learn this, you can represent all the math you did before that moment in algebra, all the pluses and minuses and timeses and so on, with functions that add or subtract or multiply or whatever. It's hopefully an insight most people get from algebra, that a function is a "machine" that could do any of the math they know so far. Each function is one particular "machine" with one way of working. When you punch numbers into a calculator and hit "=" and get an answer, you get one answer. What you just did there was a function on those numbers.

Well, the insight is actually that this covers a lot more. It covers the rest of math, too. It covers everything that can be calculated, and that means all deterministic processes. It even, amazingly, covers non-deterministic processes. It covers quantum mechanics, including the purely random, non-deterministic component of it.

When you write your function, f(x) = 20x - 4.2, or whatever it is, you're writing a little program, a scrap of code. You send something in by replacing the x. Let's try 17.

Ok, so x = 17. And so f(x) is now f(17), which equals 20(17) - 4.2. I don't really care what that number is. It isn't important. But for completeness, it's 335.8. And I didn't need a calculator for that, or even paper (being good at arithmetic is a third of my job now, I practice), but the fact I can do it and a calculator can do it is not really a coincidence. 

In Alonzo Church's idea (it's called "lambda calculus" or "λ-calculus," but as for the significance of the name, he once returned a postcard that asked this question with "eeny, meeny, miny, moe," so, really, don't worry about it), this idea of applying a tiny machine to a specific number coming in is reduced to its absolute, purest, most distilled logic. We can do this with our "f(x)" notation of parentheses or without, but the parentheses help us visualize the "boundary" of each tiny machine. You "bind" a number, 17 in my example, to another symbol, we like letters, x in my example. What we're doing is one teensy tinesy moment of memory. That right there is all of computer memory. It's all binding one thing (here, 17) to a symbol/space/slot that stores things (here, x). Data and a gap for data. That iota of memory is conceptually enough to cover - and represent - all computation.

x = 17. Memory. f(x). Process.

It seems bizarre, doesn't it?

But isn't this too simple - what if we want to work with 4 different numbers, or 15 variables containing numbers?

Good question.

When we want to work with a bunch of iotas of memory, different numbers assigned to different variables, how do we do that? We make a teensy tinesy machine for each, a function that will "bind" each one to a variable, and we put them in a chain, one sending its output as the next one's input. It's a little assembly line.

The function f(x, y, z), for example, which we can understand as a machine that works on points in 3D space to give you some corresponding piece of information about each one, can be rewritten as f(x, f(y, f(z))).

f(x, y, z) = f(x, f(y, f(z)))

We don't need a new concept at all, we just need to remember that these different functions could be different from each other. Each "f" here might mean something different, a different process from the others.

In algebra we'd say something like:

f(x, y, z) = g(x, h(y, i(z)))

Or even:

f(x, y, z) = g(y, h(z, i(x)))

Or 

f(x, y, z) = a(y, c(z, q(x)))

The letters don't matter. Just remember the three variables are (or could be) different, and the three functions are (or could be) different from each other. A function or "machine" with many inputs can be expressed as many simpler functions or "machines" on single inputs, and you don't lose any functionality (no pun intended).

But don't even worry if you're confused yet. The core idea is that we don't need a new core idea. We can just keep packaging the same idea of a function, the same kind you learned about in algebra, with one number going in and one number going out.

In fact, we can even write the numbers that way. For example, 0 can be f(). 1 can be f(f())). Those empty parentheses, by the way, "contain" nothing. We call this nothingness "the empty string." It's the twin of 0 (a symbol, agreed?) when you're talking about strings of symbols - say, that unwritten term paper or novel, or the code you're about to write to calculate a cell in Google Sheets but haven't actually written. No symbol written. Blank page. Blank canvas. No code. Empty space. 0 is a number with no magnitude. The empty string is just nothing written, but it's a math concept. Small difference, but see it?

Ok.

2 can be f(f(f()). And so on.

There are even ways to write +, -, etc, as pure functions of functions.

If it helps you to see it more clearly, let me rewrite those this way:

0 = f(nothing)

1 = f(f(nothing))

2 = f(f(f(nothing)))

Etc.

You get 0 when you put nothing in the machine. When you feed that 0 into the next machine, you get 1. When you feed 1 into the next machine, you get 2: or two machines since the 0. Two assembly line steps. Think of the function as telling you how many steps led up to it. Or you can imagine it as looking inward, counting how many functions are inside it, held within its outer parentheses. (Incidentally, I mentioned above that we need to remember the f(x)'s may not be the same function, and I replaced some of the f's with other letters to illustrate, but in this case, it's all the same f(x). We don't need to worry: it's just one function working on itself.)

We can make all the numbers this way, and actually it goes deeper. There are many ways to make all the numbers with this concept, and this is only one. It simply illustrates the potential.

We already talked about how each function has its tiny iota of memory, right? Each f(x) has an x it's responsible for keeping in mind. And so when we do f(f(f(....))), we're actually building up both memory and process. And so maybe now it makes sense that f(nothing) is a symbol for nothing, ie, 0, and it's a little less than f(f(nothing)), which is 1.

It can actually be argued that every definition of numbers and operations depends on this concept, just in different ways. Data and process. Function.

Alonzo Church realized this independently of Alan Turing at almost exactly the same time, a little after 1930. What I've just outlined above, "Church's virtual atomic math machine" you could say, is equivalent to a universal Turing machine, even though the definitions of the two concepts look extremely different. They look different, but their functionality is identical. One (Church's) has functions of functions of functions, the other (Turing's) has you imagining an infinitely long spool of magnetic tape with a read/write head that can move back and forth according to some logic using a finite number of internal states: reading, writing, overwriting, or erasing 1s and 0s on the tape, and either doing this forever or at some point stopping and leaving its final result as a string of 1s and 0s on the tape. Every programming language (all the ones that are "Turing-complete," which is most of the good ones: it just means they can in theory calculate anything calculable, even if the computer might take a long time, or run out of memory space) lines up exactly with Turing's infinite tape and read/write head vision, which is also functionally identical to Church's idea above with functions of functions.

A key piece of this I haven't mentioned, but which the MIC-1 CPU in C assignment demonstrated, is that actually you only need a finite number of functions to get up and running. It's a small number, 5-10. That function composition I wrote at the end of the assignment was not infinitely long, but what it ran was a computer. Turing machines that are fully capable have a finite number of internal states, and correspondingly, real-world CPUs only need a finite number of defined machine operations. And correspondingly again, a finite set of rules of logic is your Swiss Army knife for all logical reasoning. (This is another mathematically proven result, one from Kurt Gödel that actually inspired both Turing and Church. It's closely related.) There are probably many ways to think about and visualize this same universal machine concept, ways we haven't imagined yet. Most of the coding languages look radically different from either way, and are much more workable. The Lisp family of languages draws on Church's functions of functions idea directly and elegantly, and that's why their code is famously stuffed with parentheses... and why some people actually like that. It goes right down to this core way to think about data and process.

Note: I don't think I've defined Church's lambda calculus precisely enough here that it would equate to a universal Turing machine yet, and I'm not an expert. Also, and this is an honest mistake, there's an inaccuracy where I talk about breaking functions with many inputs down into several functions (named by different letters) on single inputs. The equations I write with f(x, y, z) aren't quite correct. They hint at how it actually works; I'll try to fix it later. (Done: haven't changed the above, see below.) But I've described the idea as well as I know how.

Now if you're curious, the error comes down to the fact lambda functions have no names, but each can store a single piece of information in a named variable. This is why different notation was needed. It does mean, specifically, that a function can take in one function, do some transformations on it, and send out a different function as an answer, which then can be run elsewhere on some other input. Look up "currying" if you'd like a better explanation.

Church's notation gets at an idea that sort of combines these ideas:

f(x, y, z) = f( g( h(z) ) ), with y = h(z) and x = g(y)

f(x, y, z) = f(x, g(y, h(z)))

As far as I understand, it can't be represented fully in normal function notation (probably why we have lambda calculus and all these programming languages, huh?), but it's the same idea, just thought about and used in a more expansive way. 1) A complicated function can always be decomposed into simpler functions, and 2) functions can process other functions and even work on themselves and give themselves and each other as answers. While a function is waiting for all its inputs to have arrived (like guests for Thanksgiving), you can consider the welcoming of each arriving input (or guest) as a function that takes the number into account by memorizing it (seats him/her/hir/them at the table) and then returns to watching for remaining inputs (straggler guests). Decomposing a strict seating pattern into an open-ended, fluid arrangement allows us to build up infinitely complicated dinners from extremely simple Lego-like bits. Remember, a function doesn't only do things. A function can also modify a function that does things. And the "atoms" that make the molecules and mountains and continents and planets of functions are these tiny units of memory and process. Everything reduces to correlations working on correlations. It seems too basic, but a lot emerges. That's the gist of it.

And that's the best I can do! Admittedly I could probably do better if I understood better!

It seems almost as if we have made this more complicated, but the core insight is that we've actually made it simpler, and now we can use this as a basis for writing a computer language - or computer hardware - or any kind of hardware - that will do anything you want. Anything you've ever seen a computer do and in theory infinitely more. Anything you see happening around you in the physical world can be encoded and worked with this way. That's zany.