How do I know this? To start with, my PhD dissertation is about compiler design. Modern compilers have four or five distinct parts: The scanner, which turns the source text into a string of "tokens" = words with a single distinct meaning. These tokens are fed into a parser to determine if they make correct sentences in the computing source language. Next the sentences are fed to a semantic analyzer to determine what meaning should be attached to these sentences. Finally the analyzed sentences are converted by the code generator into a different machine language, the ones and zeroes of the computer hardware. Optionally, at one or more phases in the process, an optimizer removes redundancies in the recognized code to make it faster and/or use less memory. Mostly faster. The scanner and code generator and optimizer are all FSMs. FSMs are easy to write and debug. Compilers are very complicated programs, so "easy" is very important. The parser is the next level up on the hierarchy, a Stack Machine, and we have very specialized programs, grandly called "compiler compilers" although they only compile the parser part of the compiler, which take a specialized programming language called a "context-free grammar" to define how the parser is supposed to work. The most popular compiler compiler is YACC (for "yet another compiler compiler") done originally for C in unix, but now the base of nearlly all CCs. The semantic analyzer requires a machine one level up from a stack machine, which (in principle) may be programmed in a "context-sensitive grammar," but when I was doing this, nobody knew how to write a compiler for context-sensitive grammars, and I believe that is still the case. Semantic analyzers are all written by hand, mostly in ordinary programming languages like C, by people who think like the top level of computing device, the Turing Machine (TM), and most often their programs cannot be restricted to anything less than a TM. Anything that can be computed, can be computed in a TM, but most TM programs cannot be run in less than a TM. Almost all human thinking is done at TM level -- or if there is a higher level, some of it is at that higher level. Almost no human thinking can happen in a FSM, almost all of it requires a higher level of complexity.
But, as I said, all computer hardware are FSMs. What gives? With vast amounts of (internal and external) memory, any computer can successfully emulate any TM -- until you run out of memory. Fortunately most TM programs are not that big; nobody could successfully program them if they were. Human thinking is at TM level, but given enough memory, a FSM can emulate modest-sized (and smaller) TM programs. Computers do this all the time. And we do this mostly in programming languages that are by nature context-free, with a small amount of context-sensitivity (variable declaration and type checking) thrown in. Only very tiny -- "30 lines of C code" -- programs get written to run as FSMs. The AI engine is one of them.
Ten years ago I didn't know anything about neural nets (NNs) but some of the people in my summer job wanted to use neural nets for the self-driving car I had laid out for them. It's a simple thing to recognize blocks of color moving around as "pedestrians" using ordinary code, and the students who chose to do that hit it out of the park. Others wanted to use NNs, so I did a crash course -- which was easy: this was before they had monetized it, so there was a lot of information on the internet, you just had to understand it. I could understand "30 lines of C code" and write comparable for myself. I got about 85% accuracy on the NIST handwritten digits database; I thought it was terrible -- I am currently getting closer to 98% accuracy on full alphabets in two different (mixed) languages and several font sizes (using straight TM code, not NN FSMs), but a professor doing research in the area, she wrote a book, and she also got 85% on the NIST data and was proud of it. The students trying to use NNs didn't finish.
Modern "AI" engines train up trillions (with a 'T') of parameters so their engines are perfectly capable of memorizing every word in the billions of lines of training data scraped off the internet, and repeating it back verbatim when prompted. It looks intelligent because every word of it was written and posted by an intelligent human being. The actual engine is somewhat more than "30 lines of C code," but not significantly different in structure. They train their engine to guess the most probable next word is, rewarding good guesses (that match the internet training text), so that the best it can possibly do exactly matches the training data. No human can even read a billion lines of text, let alone memorize it to recognize when the computer spits it out, so nobody knows that's what's happening. Occasionally a programmer will recognize her own code, but she reported only thinking the computer was very smart to think up the same code that she had posted.
This is just responding with text to text prompts. That's so yesterday. The latest craze for today is having the machine operate machines as an "agent" and doing "inferencing" (the kind of thinking people do). The machine itself is still a FSM, so in principle it cannot do human (TM) style thinking at all, but with enough memory, it can do a fair imitation by assembling strings of words it has memorized from different parts of the internet, and including more of the prompt text. Yes, that's what they do. The machines still have no clue -- not even a place in the program to store -- what the words mean, they only give out words based on the probability of that word being next in the training data. They still say that's what is happening.
The developers won't tell you this, but the better of two magazines the IEEE sends me for having paid dues for 20 years, they can afford male writers who are willing to ask the hard questions avoided by female authors (and understand it well enough to get it right). On the first page of his article in the October issue, Matthew Smith writes
Although they might seem similar, AI training and inference are computationally different [I have been saying this for several years now]. These big moves from tech giants signal that in order to support the inference demand, we're going to need a very different mix of hardware than experts may have expected, even a couple years ago.Right. Of course he's only describing the memory and data flow requirements, but the difference is far more fundamental than that: to get inferencing correct, they need to do semantics = what the words mean in this context, which is context-sensitive, two steps up from FSMs running the chat machines. Smith ends his article still a firm believer in the hokum the "AI" proponents are spitting out, but at least he admits that the hardware to support inferencing will likely promote future growth in ways we cannot imagine today.
By the way, a month or two ago I read an article somewhere interviewing children on their thoughts about "AI." Unlike most things computational, they were far less accepting than adults. One even went so far as to call it "artificial idiot." I think that is an accurate descriptor both today and for the foreseeable future.