leroy-is-here

People really struggle writing simple essays. It takes a lot of work externalizing words from your own context inside your mind so that the sentences can be understood by themselves. It’s one of the reasons we used to teach “word problems” in our mathematics classes alongside composition, but now we just want to compute arbitrary answers.

If we wrote entire books in song, they could probably be memorized. Shakespeare attempted some of that work.

Socrates’ main argument is that the word itself cannot teach but that it takes two parties which are often a student and a text instead of a student and a teacher. If Socrates sat down and explained to a student, he could impart not only the written word but other examples from their own lives. But the word can be uprooted from its context and read by many who will learn just the word instead of the meaning of the whole of it. There’s even a whole class of philosophy who argues _inside_ the definition of words.

Verifying a measurement isn’t cheating. The word exists because it is memory externalized.

Plato would still be controversial today. Imagine that you’re being told you only see images and you just imitate what you see.

I think that it is equally hard determining causes. We can clearly see differences between humans in the past and humans as we are today. Because humans are in the past, we easily think they are lesser and more stupid than our technological superior selves. But they didn’t have mass-produced cars and roads everywhere, so they didn’t die of weight-related heart failure. But labor was tougher, so perhaps those same men were getting drunk every night.

Our former selves realized everyone should have a right toward education, but we barely teach the trivium, the education of a free man. Instead we have politicized our education instead of requiring students to read Plato because even our teachers haven’t read him.

Yes, this has been a good refresher for me. I think you’re right, I am probably mis-stating some particular nuances.

So you think that AGI is a pre-requisite, a requirement, of unlocking a general, Earth-wide collective super-intelligence of humans?

The Von Neumann architecture is just a Turing Machine, simply a physical manifestation of one, a physical abstraction. My computer has a “tape” which is 64GB wide because I have 64GB of RAM.

If we had infinite memory and infinite symbols (instead of only 2^64), we could build a universal Turing Machine. But that doesn’t mean our physical computers aren’t Turing Machines executing Turing-complete programs that just happen to be in the space of programs executable in a finite time and within the limitations of our current physical realities.

I’m not sure who told you that Turing never intended for the machine to be built. He knew that he could not build a machine with infinite tape, as we both know too. But when he built the machine to crack the Enigma Machine, he did this _after_ writing his paper, “On Computable Numbers.” So, he was in effect making a Turing Machine (but he called them a-machines).

We literally didn’t have computers before Turing formalized a way to execute them, instruction by instruction, and in detail. Once we had some kind of formal method to do this, physical machines could start being built.

Edit: My comments have not shown misunderstanding. There seems to be this consensus that our mathematics here came _after_ our machines. But this is wrong and the implications are tremendous. Our computers we have really are machines which execute other machines. What is the only class of machine that can do that? The Turing Machine.

Edit2: I suppose this is an argument of semantics. I didn’t realize. Yes, perhaps our computers are “Turing-equivalent”. I still think the “tape” and “symbol” and all of those things are merely mental variables, which is why I called these things a Form earlier. We built a physical tape, it just took the form of RAM and has much detail that electrical engineers can talk about. We also built symbols, we just called them instructions and placed them into a CPU. All of our physical devices have come from theoretical findings, not vice-versa.

https://en.m.wikipedia.org/wiki/The_Treachery_of_Images

What if AGI just turns out to be exactly like the current human mind is now, except more accurate at digital calculation? What if we created AGI and then it was just lazy and wanted to read about action heroes all day?

I think the author is not taking language far enough. The animals which cannot speak do have a language, their language is just body language — one of actions. This is why when learning how to train dogs or cats, a human must learn how to control themselves and their actions.

Yes, there is not reason why AI must “speak” in English or any other human language, but any language it speaks in will be lossy in the same way. Fundamentally, all of communication is lossy including our computer programs. This is why things like undefined behavior exist and also why people misunderstand.

Our machines _can_ compute any Turing-computable function, except only up to some finite point because we must exist in this reality. Our numbers are infinite, but we do not argue they are not because someone was not able to count up to 999999999999999999999999999!

I thought about your comment a lot and here’s a way, way better illustration:

You are completely correct that we can formalize any Turing Machine as a FSM but! this _must_ include input. Again, this is just pure simulation as you state.

Again, we can write a _single_ Turing Machine program with a _single_ input baked in as an FSM and that input _must_ be finite. But that FSM is not capable of handling _any_ input like the the Turing Machine it is simulating. That’s kinda the big difference between Turing machines and machines of a lower class. Any FSM has limited input thus limited states, but a Turing Machine can run infinitely with finite input.

So, one can simulate the Turing Machine _with_ input using a FSM up to state N. But the actual Turing Machine can execute up to N+1 without having to hard-code any inputs and is capable of handling other inputs.

Again, your computer is a Turing Machine capable of accepting Turing Machines as input. We can hard-code any individual programs and make them into a physical computer chip — just as we did with our computers which can accept any input it can handle, limited only by its physical limitations. But these physical limitations are not an indicator of it being of a lower class because we can keep pushing those limitations back and still compute more of states of these programs.

Anyway, I’m glad you mentioned all of this because I went and pulled out my books.

I think your hang-up is one of infinity. Just because we must deal the reality of the finite does not mean our computers are not _capable_. For example, the Turing Machine in our minds is able to run infinitely, but the computer plugged in to my wall cannot because it is dependent on me paying the power bill.

Any Turing Machine we will have made into silicon is able to run any Turing Machine we can formulate (at this current moment in time) except only up to a finite point. But we can forever increase that finite point of measure! For example, our computers now may be able to calculate up to N. The next year, we may be able to do N+10000. The following year, N+10000000, and on and on. This is a limit of our reality, but not of the Turing Machine, which our machines must be because they are capable of being extended all the way to infinity, even if we take them there step by step, by adding 1 at a time.

Again, if this were a problem of infinity, then we would have limited the domain and solved the issue already. But we can design very simple, very finite Turing Machine programs for which the Halting Problem cannot be solved:

    while (true) {
        sleep(1);
    }

edit: you were right -- we are talking past each other. The "finite" in "finite state machine" is not useful here. Any infinite Turing Machine which we have made into silicon is still an infinite Turing Machine, just one we have inherently limited due to our realities of only having so much time or room or resources or whatever else. But a FSM is not one we limited artificially, it is a different class entirely and a class we can completely make into silicon without any sort of loss. Again, if this were a problem of "infinity" then we would have limited the domain by our own choice and solved it, which we have done for machines of a lower complexity, but _not_ for Turing Machines.

I think I agree with you, but maybe not for reasons you agree with. You see, the Turing Machine is a Form, in Plato's sense. I can formulate all of the programs and machines imaginable (at this current moment in our lifetime) with Turing's process for creating machines. The individual machines created from his process may not be able to run Turing-complete code, e.g. a calculator formalized as a Turing Machine.

But our machines, our computers, are machines which can accept other machines as input. And even in this limited domain we cannot solve the Halting Problem, so I consider them a part of the Turing Machine class even if they are descendants of Turing's Form.

Edit: In more concrete terms, one can design a very simple program in C, but that doesn't mean that C isn't capable of being used to design more complicated programs. It also isn't very useful to measure a _specific_ C program, especially a simple one, as a measure of what _all_ C programs may be able to do.

Edit^2: After thinking about this more, I think a better argument is this: it is true that our physical machines must exist in some sort of finite state, but if our big problems (such as the Halting Problem) were merely symptoms of infinity, then we would have solved them by now in our limited and finite domain.

Again, if your computer is not a Turing Machine, then it must be able to run programs that the Turing Machine class is not able.

Because the "tape" is infinite, then the possibilities to name individual machines are infinite. I can create the number of a machine which is just a simple non-deterministic finite automata using a Turing Machine description.

My point is that we can always use more powerful machines to describe less powerful ones, but that isn't an indicator that they are then less powerful.

I sign my name in cursive and do not think of it as feminine.

I think it is articles like this one which are misleading. The Turing Machine was never “built” because it is just a class of machines, i.e. particular machines are of the Turing Machine class, Turing-complete. Because the class of machine has an infinitely long “tape”, then finite machines can be created “under” it, or in that domain. Turing literally devised a method to create machines with a specific name, a number, and compute that number. Each and every one of your computers could be formalized to have a specific number, even if extremely large. Therefore, each of your computers are Turing Machines, unless of course you can show that you can run a program that the class of Turing Machines cannot.

Edit: I think the surest example of this is in the term “binary”. When you compile a C program, you get an executable binary. Literally, you have a file of ones and zeroes. Well, that’s just an extremely large number in binary, exactly the same as the binary string “100001” being “33” in decimal.

I looked at the logo to see what kind of non-sense you were talking about, but you are absolutely correct. That logo really does belong on a shampoo bottle.

Yes, if a machine can somehow start disobeying, it becomes intelligent to some degree.

And yes, I want to walk that path because I believe that intelligence is not static and everyone can grow.

These thinking machines don't choose their thoughts. They are not blank slates, waiting patiently and listening. They are just binaries that only get executed when you run them. You have your causes backwards -- _we_ give it thoughts to think by literally seeding the machine with something to think about.

Your argument about the human is also missing something: a human can ignore whatever you say to them, but these thinking machines cannot. You say that these machines have already chosen the choice to even think, but they literally cannot choose to _not_ think about what you give them. But a human can ignore whatever you say and not respond to you.

You should read the article I posted, I've already discussed these arguments.

I have no idea what argument you are making.

These machines, in our lifetime, as they are right now, cannot choose their thoughts. Literally, I want you to think of these machines as programs on the command line, because that's exactly what they are. You invoke them like this: ./chatgpt "Hello, what is 2+2?". You control what it thinks about because when it isn't thinking it is inactive, because it hasn't been ran. We control these machines, literally, and thus control what they think including the "level" at which they think -- their intelligence.

You are sentient because you can choose to ignore many of your inputs. You can choose to ignore people’s words and you can choose to ignore signals in your own body. A machine cannot choose to ignore it’s inputs.

I disagree if you are taking your argument to the conclusion that we do not have free will.

Thinking machines, like ChatGPT, do not have any intelligence because they cannot choose their own thoughts. We give them thoughts to think by our inputs and commands. Therefore _we_ give them intelligence by our inputs. Any measure of (textual) intelligence we have can be output by these machines. For example, we can ask it to do 4th grade arithmetic or graduate level mathematics.

But you are correct, eventually we will wrap these thinking machines into some sort of other machine. A machine that can observe the thoughts it produces with the thinking machine inside of it.

I talk about a lot of this here: https://leroy.works/articles/a-critique-of-alan-turings-conc...

Yes, but when or if you need to update your list of available terminals, or extend the parser because of introduced ambiguity to the language, having the lexing and parsing be separate reduces the overhead significantly.

This is why Linus uses email. It’s the Unix way — Git is just another tool. It doesn’t need to be a website, and an issue tracker, and a change proposal database, and version control software, and a social media website, and pull request tracker. It just needs to be a version control software with some decentralization.

If todays developers were tasked to build the World Wide Web again, we would all log into some oAuth portal.

What do you even mean? Github made a decentralized service a centralized one by encapsulating it. This “impact” isn’t the fault of Git at all.

What are the benefits we are supposedly enjoying?

You lex into tokens and then parse the tokens. It’s much easier to write cleaner, extensible, and maintainable code this way. For example, why have the hassle of worrying about whether you’re dealing with a string with numbers or just a number itself while parsing?