The essential claim, as I understand it, is that Lisp could not handle type union, intersection, and negation. I've been slowly working to better understand that criticism.

In this paper (p3) the author writes ( https://www.irif.fr/~gc/papers/set-theoretic-types-2022.pdf ) The more precise is a type the fewer functions it types, the most precise type being one that, as (¬false→false)&(false→true) completely defines the semantics of a function.

While I agree with the first half of the sentence about the precision of a type, it seems to me that "type" and "semantics" are categorically different.

Trying to claim that types capture semantics seems to extend an essentially mechanical process (typing) to an essentially philosophical one (semantics).

So my question is, "Am I incorrect in claiming that types and semantics are categorically different"? This matters in the kind (pun) of work I'm trying to do, especially in the struggle of defining specifications.

Like Godel, I keep struggling with self-referential and self-modifying systems (self-reproducing robots being my actual domain of research). Systems with these properties have types and semantics that can "move" over time.

A self-modifying system (e.g a neural network) could start out properly classifying inputs (e.g. cat vs dog) but over time add a third "type" of "don't know" as more training occurs. That isn't a temporal logic or fuzzy logic but more of a "morphing(?) logic". Here time is not the subject of logic reasoning but the essence of the mechanism of reasoning.

The game gets even worse as my neural nets can change structure, get feedback from their own output as input, split into and/or join with other nets, and accept their own structure as input and output (similar to genetic algorithms). The physical model is closer to yeast cells than neural nets. ( https://www.wiley.com/en-us/Yeast%3A+Molecular+and+Cell+Biology%2C+2nd+Edition-p-9783527332526 ) (Lest you think I'm joking, yeast can find optimal paths in graphs and optimally solve mazes.) All of this nonsense sits on self-modifying hardware (FPGAs).

Godel considered self-reference but not self-modification. Might a system that can't currently solve a problem slowly self-modify into one that could?