From Data Processing to Knowledge Processing: Operation with Schemas in Autopoietic Machines

Knowledge processing is an important feature of intelligence in general and artificial intelligence in particular. To develop computing systems working with knowledge, it is necessary to elaborate means of working with knowledge representations (as opposed to data) because knowledge is an abstract structure. There are different forms of knowledge representations derived from data. One of the basic forms is called a schema. The goal of this paper is the development of theoretical and practical tools for processing schemas. To achieve this goal, we use schema representations elaborated in the mathematical theory of schemas and use structural machine as a powerful theoretical tool for modeling parallel and concurrent computational processes. We describe the schema of autopoietic machines as physical realizations of structural machines. An autopoietic Machine is a technical system capable of regenerating, reproducing and maintaining itself by production, transformation and destruction of its components and the networks of processes downstream contained in them. We present the theory and practice of designing and implementing autopoietic machines as information processing structures integrating both symbolic computing and neural networks. Autopoietic machines use knowledge structures containing the behavioral evolution of the system and its interactions with the environment to maintain stability by counteracting fluctuations.


Introduction
Data are objects known or assumed as facts, forming the basis of reasoning or calculation. Data also contain factual information (such as the results of measurements or statistics) used as a basis for reasoning, discussion, or calculation. In the digital computing world, data are the carriers of information in the digital form, which can be transmitted or processed. Data can be naturally represented by named sets where the name may be a label, number, idea, text, process, and even a physical object. The named objects may be decomposed into knowledge structures with inter-object and intra-object relationships and associated behaviors, which can cause changes to their state, form or content. The role of information-processing structures is to discern the relationships and behaviors of various entities composed of data and evolve their state, form or content accordingly. Information in the strict sense includes a capacity to change structural elements in knowledge systems [1].
Conventional computers process data and provide a way to handle information stored in these data. However, a system cannot be intelligent if it cannot operate with knowledge [2]. The degree of intelligence depends on the ability to operate with knowledge. This is true both for natural and artificial systems. At the same time, intelligent systems work not directly with knowledge but employ knowledge representations of different types because knowledge per se is an abstract structure [3]. One of the most powerful and flexible forms of knowledge representations is schema.
The first known utilization of the term schema is ascribed to Kant, who did this in his philosophical works [4]. As an example, Kant defined the "dog" schema as a mental

Schemas and elements of their mathematical theory
The mathematical theory of schemas is unifying the variety of approaches to schemas in different areas. It provides a general mathematical concept of a schema on the level of generality that makes it possible to model by mathematical tools virtually any type of schemas.
According to the typology of knowledge [3], there are three basic schema types: • Operational schemas • Descriptive or categorical schemas • Representation schemas Here we consider only operational schemas and their processing while two other types and their processing are studied elsewhere.
There are three types of schema elements: objects (also called nodes or vertices), ports, and ties (also called links, connections or edges). They belong to three classes: Object/node, port, and connection/edge constants. Object/node, port, and connection/edge variables. Objects/nodes, ports, and connections with variables.
Ports are devices through which information/data arrive to (output ports or outlets) and is transmitted from the schema (input ports or inlets). There are constants, variables and constants with variables ports. For instance, a constant port P can have the variable defining its capacity.
Operational schemas also contain such objects as automata and/or automata valued variables as its nodes.
Definition 2.1. A port schema B (also called a schema with ports) is the system of three sets, three multisets, and three mappings having the following form: Here AB is the set of all objects (e.g., automata) from the schema B; the multiset VNB consists of all object variables (e.g., automaton variables) from B; the set CB is the set of all connections/links from the schema B; the multiset VCB consists of all link variables from B; the set PB = PIB  PEB (with PIB  PEB = ) is the set of all ports of the schema B, PIB is the set of all ports (called internal ports) of the automata from AB , and PEB is the set of external ports of B, which are used for interaction of B with different external systems and are divided into the input and output ports; the multiset VPB consists of all port variables from B and is divided into two disjunctive sub-multisets VPBin that consists of all variable inlets from B and VPBout consists of all outlets from the schema B; p IB : PIB  VPB → AB  VNB is a (variable) total function, called the internal port assignment function, that assigns ports to automata; cB : is a (variable) function, called the port-link adjacency function, that assigns connections to ports where P'IGin , P''Igout , V'PBin and V'PBout are disjunctive copies of P'IGin , P''Igout , V'PBin and V'PBout , correspondingly; and p EB : PEB  VPB → AB  PIB  CB  VNB  VPB  VCB is a (variable) function, called the external port assignment function, that assigns ports to different elements from the schema B.
Let us consider some examples. Example 2.1. A schema of transducer (information processing device) hardware from [28] describes an arbitrary transducer.
In a general case, the information processing device hardware consists of three main components: an input device, information processor, and output device. This is described by the following schema; Tr = (VNTr , PTr , VPTr , CTr , VCTr , p ITr , c Tr , p ETr ) VNTr = {ID, IP, OD} where ID is a variable that takes input devices as values, IP is a variable that takes information processors as values, and OD is a variable that takes output devices as values.
PTr consists of ports from the three device variables, each of which has one input port and one output port.
VPTr consists of port variables attached to the three device variables. CB is the set of all connections/links between ID, IP, and OD. VCTr is the set of all connection/link variables, which connect ID, IP, and OD. Informal visual representation of this schema Tr is given in Figure 2.1. A schema of parallel information processing device hardware describes two independent information processing devices, which can work in the parallel mode. In a general case, parallel information processing device hardware consists of the following main components: two or more input devices, two or more information processors, and two or more output device. The simplest, with two of each device is described by the following schema; PTr = (VNPTr , PPTr , VPTr , CPTr , VCPTr , p IPTr , c PTr , p EPTr ) VNPTr = {ID1, IP1, OD1, ID2, IP2, OD2} where ID1 and ID2 are variables that take input devices as values, IP1 and IP2 are variable2 that take information processors as values, and OD1 and OD2 are variables that takes output devices as values.
PPTr consists of ports from the device variables, each of which has one input port and one output port.
VPTr consists of port variables attached to the three device variables.
Informal visual representation of this schema PTr is given in Figure 2.2.

Figure 2.2.
A schema of parallel information processing device hardware.

Definition 2.2.
A basic schema R (also called a schema without ports) has the same organization as the port schema, only without ports. Thus, it consists of two sets, two multisets, and one mapping, i.e., R = (AR , VNR , CR , VCR , cR ).
There is a natural correspondence between basic schemas and port schemas. On the one hand, taking a port schema R, it is possible to delete all ports and to change all links between ports by the links between the elements of the schema R, to which these ports belong. On the other hand, taking a basic schema Q, it is possible to attach ports to the elements of the schema Q, to which links are attached in Q.

Example 2.3.
A schema of a Turing machine describes the hardware of an arbitrary Turing machine.
A conventional Turing machine consists of three main components: a control device, information processor, and memory (tape). This is described by the following schema; Tm = (VNTm , CTm , c Tr ) VNTm = {cd, h, m} where cd is a variable that takes values in accepting finite automata, h is a variable that takes computing finite automata as values, and m is a variable that takes different types of tapes, e.g., one-dimensional, two-dimensional or n-dimensional tapes, as values.
CTm is the set of all connections/links between cd, h, and m. Namely, cd is connected to h while h is connected to one cell in t.
Informal visual representation of this schema Tr is given in Figure 2.3.

Example 2.4.
A schema of an inductive Turing machine the hardware of an arbitrary inductive Turing machine [28].
A simple inductive Turing machine consists of five main components: a control device, information processor, input register, output register, and working memory. This is described by the following schema; ITm = (VNITm , CITm , c PTm ) VNTr = {ir, or, cd, h, m} where cd is a variable that takes values in accepting finite automata, h is a variable that takes computing finite automata as values, and m is a variable that takes different types of tapes, e.g., one-dimensional, two-dimensional or n-dimensional tapes, as values.
CB is the set of all connections/links between cd, h, and t. Namely, the element cd is connected to the element h while h is connected to one cell in m.
Note that in the Turing machine schema and the simple Turing machine schema, the memory is not changing in the process of computation. However, in the higher order Turing machine schema, the memory can be transformed in the process of computation [28]. This difference is not displayed in the considered here schema but can be exhibited in a more detailed schema.
Informal visual representation of this schema Tr is given in Figure 2.4.

Definition 2.3.
The grid G(P) of a (basic or port) schema P is the generalized oriented multigraph that has exactly the same vertices and edges as P with the adjacency function c G(B) equal to c B . Example 2.5. The grid of the schema Tm of a Turing machine.
Example 2.6. The grid of the schema ITm of an inductive Turing machine.
It is possible to read more about different types of schemas, their properties and mathematical models in [23,24,25] and other publications on the mathematical theory of schemas.

Operations with schemas
We discern three types of operations with schemas -large-scale, middle-scale and local operations.
Types of large-scale operations with schemas: 1. Schema processing 2. Schema utilization 3. Schema transmission Large-scale operations are formed from middle-scale operations. For schema processing, there are the following types of middle-scale operations with schemas: 1. Creation/elaboration of schemas 2. Transformation of schemas 3. Decomposition/termination of schemas Utilization of schemas includes the following middle-scale operations (stages): 1. Creation of a schema from the existing material 2. Formation of a schema instance (instantiation) 3. Application of the schema instance Middle-scale operations are formed from local operations. For schema transformation, there are the following types of local operations with schemas: 1. Compositon/aggregation of several schemas 2. Monotransformation when one schema is changed 3. Coordinated transformation of several schemas -polytransformation Let us consider some of them: 1. Outside clutching (also called external composition) con(A, B) of schemas A and B is composed by correct attaching some external ports of the schemas A and B to one another. An example of outside clutching is sequential composition, which is the most popular operation in computing. In it, the output port of one computing system is connected to the input port of another computing system. As a result, the output of the first computing system is used as the input of the second computing system.   A, a, B). In contrast to clutching, substitution is not commutative. At the same time, under definite conditions, substitution is associative. Theorem 2. Substitution of different elements in a schema is an associative operation, i.e., if a and b are different elements of a schema A, then sub(sub (A, a, B), b, C) = sub(sub (A, b,  C), a, B) for any schemas C and B.

Structural machines as schema processors
To be able to efficiently process knowledge a computer or network system must have knowledge oriented architecture and assembly of operations. The most powerful and at the same time, flexible model of computing automata is a structural machine [27]. It provides architectural and operational means for operation with schemas.
For simplicity, we consider structural machines of the first order, which work with first-order structures. In this expression, we have: the set A, which is called the substance of the structure A and consists of elements of the structure A, which are called structure elements of the structure A the set R, which is called the arrangement of the structure A and consists of relations between elements from A in the structure A, which have the first order and are called structure relations of the structure A the incidence relation r, which connects groups of elements from A with the names of relations from R Lists, queues, words, texts, graphs, directed graphs, mathematical and chemical formulas, tapes of Turing machines and Kolmogorov complexes are particular cases of structures of the first order that have only unary and binary relations. Note that labels, names, types and properties are unary relations. Definition 4.2. A structural machine M is an abstract automaton that works with structures of a given type and has three components: • The unified control device CM regulates the state of the machine M • The unified processor PM performs transformation of the processed structures and its actions (operations) depend on the state of the machine M and the state of the processed structures • The functional space SpM , which, in turn, consists of three components: o The input space InM , which contains the input structure. o The output space OutM , which contains the output structure. o The processing space PSM , in which the input structure(s) is transformed into the output structure(s). We assume that all structures -the input structure, the output structure and the processed structures -have the same type. In particular, the functional, input, output and processing spaces have definite topologies defined by the systems of neighborhoods [26].
Computation of a structural machine M determines the trajectory of computation, which is a tree in a general case and a sequence when the computation is deterministic and performed by a single processor unit.
There are two forms functional spaces SpM and USpM : • SpM is the set of all structures that can be processed by the structural machine M and is called a categorical functional space • USpM is a structure for which all structures that can be processed by the structural machine M are substructures and is called a universal functional space There are three basic types of unified control devices: • It can be one central control device, which controls all processors of the structural machine • It can consist of cluster control devices, each of which controls a cluster of processors in the structural machine • It can consist of individual control devices, each of which controls a single processor in the structural machine There are three basic types of unified processors: • A localized processor is a single abstract device, which consists of one or several processor units or unit processors functioning as a unified whole • A distributed cluster processor consists of unit processors (processor units) from a cluster, which performs definite functions in a structural machine • A distributed total processor consists of a system of all unit processors (processor units) from a structural machine It is possible to treat a localized processor as a singular unit processor although it can be constructed of several processor units, which are moving together processing information. Examples of distributed cluster processors are systems of processors that perform parallel or pipeline transformations of data in the memory.
Structural machines can process information in different modes [29]. This brings us to three kinds of structural machines: • Recursive structural machines, in which all processors work in the recursive mode • Inductive structural machines, in which all processors work in the inductive mode • Combined structural machines, in which some processors work in the recursive mode while other processors work in the inductive mode. It is proved that for any Turing machine and thus for any recursive algorithm A, there is an inductive Turing machine M that simulates functioning of A [28]. Similar reasoning gives us the following result.
Theorem 4. For any recursive or combined structural machine R, there is an inductive structural machine Q that simulates functioning of R.
Properties of inductive Turing machines [28] imply the following result. Theorem 5. Inductive and combined structural machines are essentially more powerful than recursive structural machines.
Architectural and functional features of structural machines provide diverse possibilities to perform operations with schemas. For instance, a singular unit processor can move from one location in a schema to another one acting upon the operated schema. Another option is parallel or concurrent operation of several unit processors performing the necessary transformations of the operated schema.

Computing structures for operation with schemas
Digital information processing systems of the current generation are composed of computing structures that are stored program implementations of the Turing machines. As mentioned in this paper, they are designed to transform one state of the data structure, which is a representation of the arrangement, relationships, and contents of data, to another state based on a specified algorithm. The data structure consists of the knowledge about various data elements and the relationships between them. The behaviors of how events alter the data structures are captured in the algorithm (encoded as a program) and are executed to change the state of the knowledge structure using the CPU. Digital computing structures use programming languages which operate on a variety of data structures such as characters, integers, floating-point real number values, enumerated types (i.e., a small set of uniquely-named values), arrays, records (also called tuples or structs), unions, lists, streams, sets, multisets, stacks, queues, double-ended queues, trees, general graphs, etc. In addition, word processors, such as Word or TeX, work with various geometrical shapes, figures and pictures.  .1 shows the schema and the data structure evolution of a Turing machine stored program control implementation. The schema represents the control processor that executes [28,29,30] the infware, the information processor which provides the hardware (CPU and Memory) and the software (the algorithms operating on the data structures.) The memory provides both the program and the data for processing.
In essence, information is the change between the data structures from one instant to another and information processing consists of physical structures that execute the behaviors transforming the data structures from one state to another with a Read-Compute-Write cycle of operations. The digital computing structure requires hardware (the processor and memory) and software (which provides the algorithm and the data structure). In addition, we need the knowledge to configure, monitor and operate the digital computing structure to execute the algorithm which is called the infware [28]. Current state of the art requires a third party to execute the infware (an operator or other digital automata that are given this knowledge to configure, monitor and operate both hardware and software. The limitations of this architecture are threefold: • Reacting to large fluctuations in the demand for resources or the availability of resources in a widely distributed computing structure executing on different provider hardware and software increases complexity and cost of end-to-end operational visibility and control while increasing reaction latency. • When the distributed components are communicating asynchronously, data consistency, availability and partitioning cause problems for executing non-stop high-reliability applications at scale without service disruption. • Insufficient scalability, especially, in processing the so-called, big data and the widely distributed nature of the access to both the sources and consumers of data necessitate pushing information processing closer to the edge.
In this section we discuss how the use of new theory about knowledge structures, triadic automata, and structural machines [29,30] allow us to design a new class of distributed information processing structures that use infware containing hierarchical intelligence to model, manage and monitor distributed information processing hardware and software components as a an active graph representing a network of networked processes. The infware, i.e., the processed information in the form of data structures, uses the operations on the schema representing the hardware, software and their evolutionary behaviors as dynamic knowledge structures. An autopoietic system [30,31] implemented using triadic structural machines, i.e., structural machines working as triadic automata, is capable of "of regenerating, reproducing and maintaining itself by production, transformation and destruction of its components and the networks of processes downstream contained in them." The autopoietic machines discussed in this paper which operate on schema containing knowledge structures allow us to deploy and manage non-stop and highly reliable computing structures at scale independent of whose hardware and software are used. Figure 5.2 shows the structural machine operating on the knowledge structure in the form of an active graph in contrast to a data structure in the Turing Machine implementation, which is a linear sequence of symbols. It is important to emphasize the differences between data, data structures and knowledge structures. Data are mental or physical "observables" represented as symbols. Data Structure defines the relationships between data items. Knowledge structures include data structures abstracted to various systems, inter-object and intra-object relationships and behaviors that result when an event occurs changing the objects or their relationships. The corresponding state vector defines a named set of knowledge structures, representation of which is illustrated in Figure 5.3.
Information processing in the triadic structural machines is accomplished through operations on knowledge structures which are graphs representing nodes, links and their behaviors. Knowledge Structures contain named sets and their evolution containing named entities/objects, named attributes, and their relationships. Ontology based model of domain knowledge structures contain information about known knowns, known unknowns and processes to dealing with unknown unknowns through verification & consensus. Inter-object and intra-object behaviors are encapsulated as named sets. Events and associated behaviors are defined as algorithmic workflows (defining the system's state evolution).
A named set chain of knowledge structures provides genealogy representing the system state history. This genealogy can be treated as deep memory and used for rea-soning about the system's behavior, as well as its modification and optimization. In figure 5.3, the behaviors are executed when an event induces a change. For example, when Attribute 1 in object 1changes the behavior B1 is executed which in turn may cause other behavior workflow. In this paper we use the knowledge structures to represent the schema that models how both hardware and software are configured, monitored and managed during the evolution of computations executing an information processing structure such as a business application. Figure 5.4 shows the implementation of the autopoietic machine with hardware, software and Infware used to execute a business application.

Figure 5.3: A knowledge structure modeling intra-object and inter-object behaviors
The structural machine's control processor operates on the downstream knowledge structures to evolve their states based on the event flow. At the leaf node the conventional Turing automata operate on the data structures to evolve traditional computing processes. The important innovation here is the regulatory overlay to discover/configure, monitor and manage the traditional computing process evolution using the local knowledge of how the local IaaS and PaaS are configured, monitored and managed while coordinating with global knowledge to optimize the end to end system behavior in the face of fluctuations.
The schema in Figure 5.5 describes the hardware components, software components and their management characteristics defined by knowledge structures forming an autopoietic automaton. The knowledge structures represent this schema in the form of a system of named sets containing various data elements, objects or entities that are composed of the data, their inter-object and intra-object relationships and behaviors associated with events that cause changes to the instances as time progresses [27].

Conclusion
In this paper, we described theoretical and practical computational tools for working with knowledge structures such as schemas taking into account their inter-and intra-relationships and associated behaviors when events change the state. We use triadic structural machines described in this paper to perform operations with schemas. The result is the design and implementation of autopoietic automata that are capable of regenerating, reproducing and maintaining themselves by production, transformation and destruction of its components and the networks of processes contained in them. Based on autopoietic automata and triadic structural machines working with schemas, we are currently building a system that models, monitors and manages a distributed application deployed over multiple cloud resources to respond to large fluctuations in the demand for or the availability of computing resources in the system without disturbing the end to end transaction being delivered by the computing structure.
It is important to point out the difference between current state of the art based on the classical computer science (constrained by the Church Turing thesis boundaries), which process information in the form of symbol sequences, and the current advancement of the field based on structural machines, which process information in the form of dynamically evolving network of networks represented by various schemas. As a result, we obtain autopoietic machines which are capable of regenerating, reproducing and maintaining themselves. The control processors in an autopoietic machine operate on the downstream graphs where a transaction can span across multiple distributed graphs, reconfiguring their nodes, links and topologies based on well-defined pre-condition and post-condition transaction rules to address fluctuations for example in resource availability or demand. The information processor of the machine, on the other hand, evolves the application workloads using the algorithms specified as programs operating on symbolic data structures.
Triadic structural machines, provide the theoretical means for the design of autopoietic automata whereas Turing machines cannot do this. The hierarchical control process overlay allows implementing 4E (embedded, embodied, enactive and extended) cognitive processes with downstream autonomous components interacting with each other and with their environment using system-wide knowledge-sharing which allows global regulation to optimize the stability of the system as a whole based on memory and historical experience-based reasoning. This observation points out a major breakthrough in the way we design future information processing systems with hierarchical intelligence and resilience at scale. We conclude this paper with the following observation from Leonardo da Vince. "He who loves practice without theory is like the sailor who boards ship without a rudder and compass and never knows where he may cast.".

Conflicts of Interest:
The authors declare no conflict of interest.