In the QSMM framework, a generic building block for creating machines capable of goal-directed adaptive behavior, which implies automated synthesis of algorithms for achieving a goal, is called an actor. One can think of an actor as a set of neurons, possibly very large one. An actor has a number of adjustable modes, parameters, supports limited customization of its algorithms, and actually implements a probabilistic mapping—a function that ambiguously maps an argument from a set of possible arguments to a result from a set of possible outcomes. Such function, when invoked one time, can return one result, and when invoked another time, can return yet another result for the same argument.
Behavior of probabilistic mapping is modulated by spur. Supposing a result returned by a probabilistic mapping for its specific argument somehow affects spur increment velocities, the function of the atomic building block of an intelligent machine that corresponds to a particular argument of the probabilistic mapping will be returning more often a result of the mapping that maximizes those spur increment velocities. An intelligent machine might include various superpositions of probabilistic mappings, its inputs and outputs, and those superpositions would specify an adaptive generic state model aimed to solve general or specific problems.
An important concept related to the possibility of using a result of a probabilistic mapping (directly or after transforming) as an argument (or as its part) of that probabilistic mapping is state—a variable that changes its value based on its previous value. A machine typically uses various kinds of states that can be interlinked in different ways and make up its whole integral state. An integral state of the machine corresponds to a point in solving an assigned task. If to solve an assigned task the machine has to interact with the environment, then the integral state will somehow link with a state of the environment. By implementing probabilistic mappings, the QSMM framework provides the means for goal-directed tracking of the current environment state which may be needed to know when producing goal-directed adaptive behavior.
If a machine executes an algorithm, possibly in the process of synthesizing of that algorithm, then the integral state of the machine will be in some way linked with a state of the algorithm, which was put in the algorithm by its developer. Principal states of algorithms are better investigated by example of deterministic finite automatons, which representation in a programming language could correspond to assembler programs with specially organized instruction sets. Those instruction sets include: (1) custom instructions, which perform effective work and can return an outcome from a set of possible outcomes; (2) conditional jump instructions, which transfer control to a custom instruction at a specific location in the program on the basis of an outcome returned by a previously invoked custom instruction; (3) simple jump instructions that transfer control to a custom instruction at a specific location in the program unconditionally. In such assembler programs, principal states of the algorithm are custom instructions and jump instructions specify mappings between those states. An argument of mapping is a superposition of a prior principal state and outcome of a custom instruction invoked in that state. The result of mapping is a new principal state. By using probabilistic mappings supported by the QSMM framework instead of hard-coded deterministic mappings, a researcher can develop adaptive assembler programs that produce goal-directed behavior.
As one may realize, adaptive assembler programs are related to automated synthesis of algorithms. The QSMM framework provides the means to work with such assembler programs that include converting the text of a fuzzily specified assembler program to a system based on one or two probabilistic mappings, executing the assembler program with simultaneous adjusting jump probabilities to solve an assigned task more efficiently, and converting a resulting assembler program back to a text representation.
Elaboration of the concept of environment for synthesis and execution of assembler programs is a multinode environment (model) in which different nodes can contain different assembler programs. In the QSMM framework, node means a callable state submodel. An assembler program of one node, when being executed, can call another node, i.e. transfer control to that node to execute its assembler program and then transfer control back after finishing execution of the latter program. Nodes correspond to subroutines, which synthesis and execution a researcher could relate to setting up processing chains with production and the use of different work tools.
As a helpful add-on for developing intelligent machines by means of C programming language, the QSMM framework provides an API for exchanging data packets in multithreaded programs, which can be used to simplify communication between different parts of your application, and a C implementation of functionality of STL
multimap templates, which can be used to create mapping objects in C programs without the need to rewrite those programs in C++ and, therefore, increase their complexity.