AGI: COMPLEXITY LEVELS OF INTELLIGENT SYSTEMS
When discussing AI/AGI, we mean computer systems, that is, programs that manipulate specific data and are represented by the corresponding source code.
The simplest program category manipulates numbers exclusively: numbers represent data from sensors, and numbers represent data sent to actuators; arithmetic operations are used for calculations. The source code does not contain rules defined by if-then-else, switch-case statements, and loops with non-constant parameters; no semantic constructs explicitly or implicitly use Boolean variables. The number of operations in the main loop and execution time are unchanged. Such programs are essentially identical to analog controllers (for example, the widespread PID controllers). It is probably problematic to build an AGI system on this basis.
The next level of complexity is represented by systems that use logical variables (Boolean variables, enumerations, classes) defined in the source code. Manipulating such variables requires logical (non-arithmetic in meaning) operators (if-then-else, switch-case, loops with non-constant parameters). From an AI perspective, the semantic type of a boolean variable represents some concept - as opposed to a number. For example, a Boolean variable indicates the presence or absence of a logical object (event, state, etc.), and the enumeration element indicates a variety of concepts from a series of similar ones. That is, this type of system operates with concepts along with numerical values.
It is important to distinguish between the data type of logical variables, which depends on the programming language, and the semantic type, which does not depend on the programming language (for more details, see SEMANTIC DATA TYPES). Different semantic types can be represented by the same programming language data type (for example, the value of "velocity > VELOCITY_THRESHOLD" has a boolean data type, but the semantic type corresponds to the concept "velocity exceeds predefined threshold"). The semantic type of such boolean variables is often described by comments and/or the meaningful name of the variable or class.
Since, as noted above, we are talking about semantic types of logical variables described explicitly in the source code, the corresponding system operates with concepts from a fixed set predefined by the source code. The number of logical objects corresponding to a logical concept can be arbitrary and variable (a collection of logical objects corresponding to the same concept).
Naturally, this category allows you to create much more complex systems. Still, the capabilities of the system are limited by the fact that all concepts used in one way or another by the system, and all rules used by the system to manipulate human concepts/objects, are predetermined explicitly or implicitly by the source code; a set of concepts and rules is unchanged in the functioning of the system.
Finally, the third level of complexity is systems capable of expanding the used set of concepts defined by the source code during operation. As noted above, the same programming language data type can represent semantically different objects. To distinguish between different concepts (semantic types), in this case, tags/labels/names unique to the concepts are used. The autonomous generation of a new concept by such a system means, among other things, the generation of a unique name/label/tag for this concept.
Of course, such systems require a subsystem for storing data about concepts, connections/relations between them, and rules for manipulating concepts, without which new concepts cannot be used. Semantic graphs ( SEMANTIC STORAGE II) are a natural store for such data.
With all their logical simplicity, systems of the simplest first type can nevertheless have quite complex and useful functionality; in particular, a “classical” neural network is an example of a system of the first type. Such neural networks can, for example, effectively approximate numerical data, which allows them to be used for prediction based on extrapolation.
Modern neural networks, including those that are the basis of various implementations of LLM ("Large Language Model"), belong to the second level of complexity.
For systems that provide the possibility of autonomous self-learning, a third level of complexity is naturally required; it may use neural networks as a component of the system or not use them, but it certainly requires the presence of a subsystem for storing concepts, relationships between them and rules for manipulating concepts (rules of inference), which cannot be implemented using a neural network with a predetermined structure - it is required to use a semantic graph of variable structure.