Just come to mind that there is yet another thing AI impossible without, that was nearly erased from comuter science.
It is self-modifying code. In 60s, programming language LISP was developed. (notice, again before that pivot date - 1970!) One of very cool features of that language was not functional approach, but a possibility of running program code creation and modification. This feature named "lambda expression" and it really created new machine code, never written by programmer and then execute it on-the-fly. You could wrote expression like "create a new function with given operation", and then program could create (as new, additional machine code) different functions if necessary. It was not fully self-modifying code, you had to describe creation process, and it was you, not program who decide whether to create new code, but still it was a very important step towards real self-modifying code.
However, after 1970, this approach, when program modify itself as it executes, was declared bad, wrong and harmful without any solid reason. The idea that it is bad practice to write a programs that modify its own code was spreaded along with same bad practice blaming of calculated goto's and other handy things and programmers tricks. Today, even LISP machines don't have that feature, and that "lambda" thing is implemented without using real new code generation.
"Bad practice" blaming worked perfectly. Self-modifying code become something inapropriate and today there are no any noticeable research on that topic at all.
Artifical intelligence is completely impossible without an ability of AI program to modify itself adjusting to environment and development of consciousness. But everything that could lead to creating of that very important ability for AI was supressed since 1970.
PS: And no, ability of all that dumb ANNs like ChatGPT/Bard/whatever to show you most probable piece of code written by humans for your request have absolutely nothing to do with self-modifying code concept.
What about functional languages such as scala? They are deterministic in a sense but do result in election flows that are modified after initial execution
All LISP descendants and other functional languages do not implement any features with self-modifying code or code creation on-the-fly. All features done in "good practice" manner. AFAIK, most common approach is to parse sources, find all lambda calls and create all possible function variants that should be returned by lambdas in advance. On execution, it just execute apropriate precompiled piece of code that is already there.
The only widespreaded lisp implementations that still do its lambdas in original, runtime new code generation way is clisp and sbcl, AFAIK.