Parametrical T-Gate for Joint Processing of Quantum and Classic Optoelectronic Signals

Abstract

Unmanned network robotics is a new multidisciplinary field that involves many fields of computer networks, multi-agent systems, control theory, 5G and 6G Internet, computer security, and wireless quantum communications. Efficient conjugation of such technologies needs to design new data verification schemes for robotic agents using the advantages of quantum key distribution lines. For such schemes the joint use of known fuzzy logic parametrical $T$-gates and discrete multiple-valued logic models simplifies the application of quantum quasi-random keys. Namely, the separate regulating parameter in $T$-gates is the most convenient tool to use quantum keys in comparatively simple classical control and verification procedures that do not involve quantum logic gates.

1. Introduction

Quantum cryptography and computing [1,2] are modern trends in communication networks, and their applications are now items for discussion. Potentially, they can solve many actual problems of network robotics, including the Internet of Things (IoT), Internet of Vehicles (IoV), delivery drones, unmanned manufacturing, medicine, and smart cities [3,4,5,6,7,8]. Respectively, quantum technologies should intensively interact with various types of software agents (or bots) and hardware robots in the Internet network medium. However, such interaction can be based on different logic models and architectures, including traditional precise models and approximate ones based on fuzzy logic (FL) [9]. Although autonomous robotics is not sufficiently provided by high-quality components in the fields of computer vision, sensors, effectors/actuators, and energy supply, an interesting discussion [10] has emerged referring to the role of well-known close-loop control schemes in such global fields as law and artificial intelligence (AI) regulation of network agents by governmental agencies [1]. Besides this, new models for business control are being designed using the customer relationship management (CRM) strategy [11]. In fact, these designs indicate the trend to develop a global structure of universal rules for robots and agents, such as human beings. Indeed, if robots gradually learn to imitate people, then they should also reproduce humans algorithms of social and group interaction. However, some earlier designed logic methods, like those well known in the FL’s $T$-gates (or $T$-norms and $T^{*}$-conorms) [12], were not in demand, but now they can be recalled in combination with quantum key distribution [1,2] and multi-parametrical modeling, based on discrete $k$-valued logic [9,13].

As all existing logic methods of data processing [9,13] are the product of the human intellect, they can be regarded as one of the aims of artificial intelligence (AI) [14] in the sphere of multi-agent models and the collective interaction of robots [15]. But in fact, the variety of known logic models demonstrates that none of them can solve all actual problems, and they should be somehow combined for specific tasks [9,13,16].

Such a discussion of logic control procedures in network robotics is relevant to include the discussion of possible schemes for the interaction of quantum and classical signals in the control contours of network agents. Now the application of quantum computing in autonomous network agents seems to be a distant prospect due to the lack of adequate quantum memory devices and the necessity of cryogenic temperatures. But quantum key distribution (QKD) lines [1,2] and quantum generators of quasi-random numbers [17] can already propose some useful solutions for the data protection of agents in wireless networks. E.g., schemes of secret coding with one-time keys were proposed to be combined with blockchain models for data verification in network agents [9,13]. These designs provide “economical” non-stream use of quantum keys, periodically received from a QKD line and involved in the hashing of critical data in agents [18]. However, the next step is to use such keys for control and verification of distant robotic agents, but the problem is that quantum protocols [13] use complicated enough schemes for measurements of single photons, which may suffer from external factors creating interference, disturbance, and noise, thus being less predictable and reliable devices. Meanwhile, controller devices with critical life cycles in agents should provide continuous monitoring of internal processes, as possible current deviations due to errors and faults need a regular and adequate reaction. For example, the multiple-valued logic (MVL) model [13] of the optoelectronic position-based cryptography protocol [19] involving entangled photon pairs should foresee reply actions in the event of non-correct running of this protocol. Such actions may require the activation of additional clarifying procedures involving sensors and data transfer channels. That is why, for the simplification of agents in IoT and IoV, it is desirable to somehow separate the processing of precise data from classic critical subsystems and probabilistic data coming from the quantum module. Possible solutions can be proposed here if one returns to the analysis of some aspects of homeostatic models and fuzzy controllers.

1.1. Homeostatic Model of Equilibrium in Medicine, Biology and Technique

Homeostatic models in physiology and medicine have been discussed for many years and have substantially influenced concepts of modern fuzzy controllers, but they were not accepted immediately. The current state of these studies can be found, e.g., in [20]. Such investigations demonstrate:

• The general scheme to sustain internal parameters of live systems in some limited bands.
• The substantial role of feedback mechanisms, including negative and positive ones.
• The joint work of two organ systems necessarily maintains homeostasis at the equilibrium state by means of the regulation of disturbances emerging in the body.

Strictly speaking, homeostasis [21] is the equilibrium state created by the large number of processes emerging in a live body for the control of its internal media. Such a model is effective for the regulation of temperature, glucose levels, the lymphatic system, blood pressure, the balance of acids, the urinary system, the nervous system, and even psychological effects.

Useful review “Homeostasis: examples, mechanisms, function” by C. Brown can be viewed on the website https://warbletoncouncil.org/ejemplos-de-homeostasis-14502, (updated 25 June 2023). Homeostasis schemes cited in this network resource refer not only to the human body but also to the biological subsystems of animals, corals, the carbon dioxide interaction cycle, and the recycling of water in the jungle. Such examples demonstrate the similarity between biological models and human intellect-produced artifacts such as thermostats, autopilots, controls in industries, and business processes. As one can assume, business processes resemble homeostatic models as they also include a large number of actors, such as cells in the live body.

Certainly, homeostasis models are also supported by theoretical modeling; see, e.g., [22]. The emulation of such schemes of control processes can combine both precise and approximate fuzzy logic models.

1.2. Possible Logic Platforms for Network Agents

Boolean logic [12], which uses only two truth levels of 0 and 1, is now the predominant method [9,13], whose victory was mainly determined by advances in microelectronics and software designs. Nevertheless, the discrete MVL models [15,16] also have a long history and interesting properties. Fuzzy logic, proposed by L. Zadeh [23,24], has become especially popular, as it is the most actual component for network control of various actuators and effectors in robotic agents. However, besides it, some models of continuous and hybrid logic are also possible [25,26,27,28,29]. As it was already mentioned in [9], neural network methods of deep learning [29] are actually for pattern recognition tasks. In fact, neural networks are the further development of almost forgotten schemes of threshold logic [30], which have become the distant ancestor of modern deep learning schemes.

Fuzzy logic [23,24] refers to the class of Kleene algebras [27,28], using continuous descriptions of truth-levels in the band [0,1] and fuzzy inference rules for approximate reasoning. Fuzzy logic has some limitations in obtaining 0 and 1, but it still proves to be a very flexible tool for control tasks and for learning procedures in combination with neural networks [29].

Effective partners for fuzzy logic have become traditional proportional–integration–differentiation (PID) controllers; see, e.g., [31]. Their combinations with fuzzy controllers provide enhanced characteristics and easy learning, also demonstrating the actuality of the heterogeneous logic architecture [9], not only for the agent level [13], but also for their internal controllers. In Figure 1a, cited from the paper [31], one can see the example of the so-called fuzzy-fractional-order-proportional-integral-differential controller (FFOPID) [32]. It is the advanced version of the well-known PID controller and has provided improved fast-response and non-linear characteristics, modeled by non-linear polynomials. Besides traditional Boolean logic, the FFOPID scheme [31] has used fuzzy logic, which gives fast approximate computing and simplifies the learning of the system but needs special logic operators for the approximate modeling of the fuzzy “modus ponens” compositional rule [33,34]. The design of such joint procedures takes into account the incompatibility of Boolean and fuzzy logic operators, which should be run only as separate procedures [9,13].

In Figure 1a, $y\left(t\right)$ is the plant behavior (variations, drawn by the control system), $r\left(t\right)$ is the vector of the control signal, $e\left(t\right)$ is the error function, $d/dt$ is the derivative of the error function. During the work cycle of this device, the fuzzy system evaluates increments for parameters $\delta Kp$, $\delta KI$, and $\delta KD$, describing proportional, integral, and differential components for the output signal of the fractional-order PID controller. However, the design of such schemes for distant robotics reveals the necessity to add confidential control, verification, and self-restoration procedures [31], which, on the one hand, motivates the use of quantum optics for confidential data exchange but, on the other hand, complicates the design of such procedures. The most obvious and appropriate possibilities to insert additional verification procedures into the scheme are shown in Figure 1b and refer to time intervals: (1) during the sensor’s data acquisition cycle, when both basic controller modules are free; (2) during the work of differentiator d/dt, when both modules are free; and (5) after the stop of the PID module, when effectors act on the plant. For a circuit board containing, e.g., two different chips for fuzzy and PID modules, one can also use time intervals (3), when PID is free and the fuzzy system is busy, and interval (4), when the fuzzy system is already free but PID is still running. Thus, the possibility to correct and check codes strongly depends on the closed-loop control cycle $T_c$, the number of used chips, and the circuit board design. Respectively, additional verification and correction tests should be synchronized with the main closed-loop cycles of controllers in the agent. But the intention to add here confidential but unpredictable quantum control data creates the necessity to foresee a separate control channel for fast regulation by means of probabilistic quantum data.

The possible way to simplify the solution of such a task is to use the generalization of fuzzy logic based on triangular $T$-norms and $T^{*}$-conorms [26,34,35,36,37], or parametrical logic with additional control channels in logic gates. Although such models were intensively researched earlier and did not give radical advantages, now such methods can simplify verification algorithms using quantum data channels.

The design of controllers with different triangular norms is described, e.g., in [33,34]. Principally, the main steps of fuzzification, fuzzy inference calculation, and defuzzification refer to any of these operators, and the efficiency of the norms used is to be tested by comparison with specific controllers, so these aspects are not included in this paper. But the emulation of such logic gates by MVL with discrete truth levels [38] is proposed further to vary the spectrum of verification schemes accessible for agents using fuzzy controllers, as this calculus additionally provides guaranteed correct multi-parametrical modeling for template matching, secret coding, and the agent’s AI functions [9,13].

However, other traditional AI methods, such as logic reasoning [14], may also be used besides the Boolean, fuzzy, and MVL models; here one can be reminded, e.g., of non-monotonous logic [39,40], where one event changes radically the decision-making scheme by the re-switching of decision rules. For example, the QKD line can deliver the byte or the bit, which secretly activates another mode of decision making. Some more specific applications were also proposed for temporal logics and Kripke diagrams [41,42], extending Boolean methods for the prediction of time-dependent processes.

1.3. Specifics of Quantum Schemes, Substantial for the Design of Network Agents

Besides logic modeling, the design of network robotics involves many other aspects, such as data security and communication line throughput. The main advantage of the QKD line [1,43] is the non-cloning theorem [44], ensuring that only both sides of the quantum line have obtained equal quasi-random keys with a necessarily small error probability. Respectively, quantum key distribution in network robotics is not only the source of quasi-random keys for secret coding [45] in verification procedures [13] but also the way to exclude long retention of secret keys in distant agents, which can potentially be attacked by eavesdroppers.

However, modern QKD lines now have some uncorrected drawbacks [1,44,45], as their real length is limited up to ~100 km (without yet realized quantum re-translators), they are still vulnerable to specific types of attacks, have a large cost, and can be blocked by intensive noise signals. That is why modern autonomous robotics cannot be based only on quantum cryptography tools but should combine them with traditional tools for data coding and verification of identity, combining Boolean and other logic models for passwords, codes, reasoning, and image processing.

Besides this, an additional non-evident problem for QKD lines is that quantum cryptography equipment is the type of device strictly certificated by NIST (National Institute of Standards, USA) and other national regulators, which prevents individual users from modifying commercial modules. That is why, in fact, experimental schemes cannot be directly united with commercial QKD modules in original customer procedures, and one should somehow duplicate such high-cost modules. For example, the position-based cryptography verification protocol [19] with entangled photon pairs can be correctly described by the MVL model [13], but such a scheme cannot be simply integrated into a commercial QKD line, which will then need separate certification. As a result, it may be easier to use the quantum line as a separate cascade, switched to the agent via the special interface.

One of the possible tools to simplify the integration of quantum technologies with logic methods is the heterogeneous logic architecture of an agent [9], which proposes a scheme to combine precise and approximate (i.e., fuzzy logic) schemes by means of discrete MVL switching functions.

1.4. Heterogeneous Logic Architecture of the Agent for the Integration of Precise, Approximate and Quantum Data

The design of logic models can be attributed to the earlier proposed [9] extended version of the traditional OSI model of computer networks, which considers the separate level of logic modeling for agents and the heterogeneous architecture of the agent. Besides this, the application of quantum signals may further adjust the set of logic tools.

One of the motives for using a heterogeneous logic architecture for agents is the actuality of various verification schemes for network agents, e.g., for the route verification task [16]. It mainly refers to the problem of identity verification, where some external checkpoints should approve visits by the mobile agent following the given route. Special limitations for map zones, speed, noise, and industrial waste disposal dictate the application of a vast number of possible schemes for verification of identity and current parameters [13,16], which can be approved by loyal network nodes or by special trusted terminals. Namely, the necessity to combine passwords, images, and quantum keys with data taken from neural networks, computer vision, and blockchain schemes is the reason to use heterogeneous architecture for multi-parametrical and multi-channel verification. Such models need effective control of various logic models and schemes for mutual monitoring of agents, where discrete MVL functions are quite a comfortable tool to coordinate AI procedures and data protection schemes.

As it was discussed in [13], for the task of position-based cryptography, the verification protocol combining quantum and classical measurements can be easily represented by the MVL function, using the time parameter as one of the input variables. Then the measurements of entangled photon pairs and classical optical signals in the wireless verification scheme can be given as a set of rows of the MVL truth table and further represented as the equivalent set of logic expressions. The whole procedure was modeled in [13] as the interaction of the prover (agent) approving his space location and pairs of external verifiers (trusted agents) emitting quantum and classic test signals. The obtained result was described by the logic function $F_{VP}$, represented as a maxterm, i.e., the set of logic expressions combined by the MAX operator ($\mathrm{or} \vee$), where each of the 21 involved logic expressions is a product term, such as $Const\wedge X_{tp}\left(t_2,t_2\right)\wedge X_{\psi }\left(\psi ,\psi \right)\wedge X_{jp}\left(j_{p2},j_{p2}\right),$ containing so-called operators Literal $X\left(a,b\right)$ combined by the MIN operator ($\mathrm{or}$ $\wedge$). (Such logic operators are discussed in detail in Section 2.1 and Section 2.2). Respectively, in [13], logic expressions have combined classical and quantum parameters measured at various time moments. Principally, any other quantum protocol or its combination with classical data can be represented by means of the complete set of MVL logic operators. It is substantial that such a logic model can also describe tolerance “windows” for imprecisely determined events, characterized by uncontrolled delays. As even the advanced position-based verification protocol by D. Unruh [19] provides only partial improvement and cannot guarantee unconditional security, additional combinations of quantum and classical procedures can be useful for the design of improved verification schemes. Moreover, another innovation in [13] was that the discrete MVL model can include some appropriate noise level, which is specific to real systems. Respectively, a corresponding logic expression was proposed, written via Literals with modified parameters $a,b$. Besides this, a data protection scheme with blockchain components was proposed [13,18], realizing the logic linked list for network agents.

However, the further design of AI methods needs to propose schemes to imitate such human ability, such as the monitoring of the correct agent’s interaction in case of faults and errors, if, e.g., some intentional or technical noise disturbs or blocks the quantum data line, or if it is necessary to take into account possible errors of involved classical subsystems.

1.5. The goal of the Paper

As the final aim of AI systems is to imitate the maximal number of useful human abilities for autonomous agents with good skill levels, one of the actual tasks is to adapt quantum optics for complex control methods in agents. In order to employ various verification procedures in the collective work of agents, it is proposed to use parametrical $T$-norms and $T^{*}$-conorms either as separate modules in verification schemes or to apply them instead of the most popular MIN and MAX operators in emulations of fuzzy logic schemes for enhanced control. These methods are intended to combine confidential data control by means of quantum lines with the flexibility of parametrical fuzzy logic.

2. Method: Operators MIN/MAX and Parametrical $T$-Norms/$T^{*}$-Conorms

A detailed description of basic logic operators in Boolean, MVL, and fuzzy logic can be seen in [12,23,24,25,26,27,28,34,35,36,37,38,39,40,41,42], as the presented work is mainly concentrated on some practical aspects. The Boolean logic model operates with the truth levels 0 and 1, and the fuzzy logic, which is convenient for fast approximate modeling, exploits the infinite number of truth levels for continuous variables $x,y$ taken in the band [0,1]. However, practical applications successfully exploit their discrete approximations by 8-bit or higher platforms. Such platforms can also emulate the discrete $k$-valued Allen–Givone algebra (AGA) [38], in which discrete truth levels may have values from $k=3$ up to $k=256$ and higher [8,13,16].

The most common types of operations for all of the above logic models are the logic complement $\overline{A}$, the Union $A {\displaystyle \cup } B$, and the Intersection $A {\displaystyle \cap } B$ of sets $A,B \left[26,33\right].$ In turn, specific cases of the Union and Intersection operations are the MINIMUM or $\mathrm{MIN}\left(x,y\right)$ and the MAXIMUM or $\mathrm{MAX}\left(x,y\right)$ operators, which are basic primitives used in the fuzzy logic and MVL. Principally, in Boolean logic, the most known full set of operators includes negation $NOT$, conjunction $AND$, and disjunction $OR$ operators, where $AND$ and $OR$ are the specific cases of MIN and MAX operators. Their extensions refer to parametrical T-norms/T*-conorms, which are used in fuzzy logic.

2.1. Specifics of Fuzzy Membership Functions and $T$-Norms/$T^{*}$-Conorms

Fuzzy systems are the well-known infinite-valued logic models, which were proposed by L. Zadeh [23,24] and are actively being used now. These models have further caused the design of more general mathematical models of $T$-norms and $T^{*}$-conorms [12,35,36], often called triangular norms. Formal definitions of $T$-norms/ $T^{*}$-conorms can be seen in [12,35]; for beginners, one can recommend the book [33], which contains many illustrative remarks.

FL operates with fuzzy sets [1,2], where a fuzzy set A is defined in a universe of discourse U and is characterized by a membership function (MF) μ_A, which can have values only in the band [0,1], i.e., ${\mu }_A: U\to \left[0,1\right]$ and is the grade of MF. In other words, any fuzzy set A consists of ordered pairs:

$$A=\left\{u,{\mu }_A\left(u\right)/u\in U\right\},$$

(1)

where MF ${\mu }_A\left(u\right)$ principally can have an arbitrary shape, which is limited by obligatory conditions, that is, the convex curve, and is normalized to 1. Such MFs are shown in Figure 2a,b. But the most popular profiles of MFs, which simplify calculations, are the triangular ones, as in Figure 2c. It is typical for fuzzy control tasks to use linguistic variables T(x)= { $T_1$, $T_2$,…,$T_k$}, briefly describing a set of linguistic values $T_1$, $T_2$,…,$T_k$ with corresponding MFs ${\mu }_i$(x) $=$ {${\mu }_1\left(x\right)$, ${\mu }_2\left(x\right)$,…,${\mu }_k\left(x\right)$}. Such a case is shown in Figure 2c,d, where input variables and the output variable are described by linguistic values $n,z,p$, and $nn,n,z,p,pp.$ Such MFs can be used in a fuzzy logic controller, which stabilizes, e.g., the rotation of the electromotor by means of measurements of the rotation speed and its derivative. Such a structure of membership functions provides the stabilizing task near equilibrium, as is typical for electromotors in effectors and for various homeostatic contours discussed in Section 1.1.

MIN/MAX logic operators [23,24,38], as well as $T$-norm and $T^{*}$-conorms, are defined as two-place non-decreasing functions, mapping [0,1] × [0,1] → [0,1]. For variables $x_1$и $x_2$ with corresponding MFs $\mu \left(x_1\right)$,$\mu \left(x_2\right)$, these operators choose, respectively, the smallest or the largest of values in the pair $\mu \left(x_1\right)$ and $\mu \left(x_2\right)$:

$$\begin{array}{c}\mu \left(x_1\right)\wedge \mu \left(x_2\right)=MIN\left\{ \mu \left(x_1\right), \mu \left(x_2\right) \right\}\\ \mu \left(x_1\right) \vee \mu \left(x_2\right)=MAX\left\{\mu \left(x_1\right),\mu \left(x_2\right)\right\}. \end{array}$$

(2)

Laws for these operations include the well-known properties of commutativity, associativity, distributivity, idempotence, absorption, absorption of complement, De Morgan’s law, and some others. MIN/MAX operations are shown in Figure 2a,b, where membership functions ${\mu }_1\left(x\right)$ and ${\mu }_2\left(x\right)$ has an arbitrary convex shape. However, $T$-norm and $T^{*}$-conorms have triangular membership functions, such as in cases c), d), which simplifies calculations for control tasks.

As one can see in [23,24,33,34,37], fuzzy logic is often used in automatic control tasks and fuzzy logic controllers (FLC), which exploit the fuzzy inference scheme proposed by L. Zadeh and models of controllers by E.H. Mamdani, and T. Takagi-M. Sugeno.

The basic fuzzy inference scheme [23,24] describes the calculation of approximate consequences based on approximate antecedents. In its simplified form, it can be written for input variables $x_1\dots ,x_M$ and output variables $y_1\dots , y_N$ as a set of $p$ “If…Then…” rules:

$$\underset{\_}{IF} x_1 is {\mu }_{a_{11}}, \dots , x_M is {\mu }_{a_{1M}} \underset{\_}{THEN} y_1 is {\mu }_{b_{11}}, \dots , y_k is {\mu }_{b_{1N}} else (\mathrm{rule} 1)$$

(3)

$$\underset{\_}{IF} x_1 is {\mu }_{a_{p1}}, \dots , x_M is {\mu }_{a_{pM}} \underset{\_}{THEN} y_1 is {\mu }_{b_{p11}}, \dots , y_k is {\mu }_{b_{pN}} (\mathrm{rule} p)$$

But for original designs of FLCs out of MATLAB software, one is to use non-simplified formal expressions; we further follow the version of expression [46,47] for the parallel calculation of $n$ output membership functions ${\mu }_{b^{*}}\left(y_k\right)$, depending only on one of the output variables $y$. Such functions can be written as

$${\mu }_{b^{*}}\left(y_k\right)=\underset{p\in P}{\vee }\left(\right(\underset{j\in J}{\wedge }(\underset{x_j\in X_j}{\vee }{\mu }_{a_{pj}}\left(x_j\right)\wedge {\mu }_{a_j^{*}}\left(x_j\right))\left)\underset{k\in K}{\wedge }{\mu }_{b_{ik}}\left(y_k\right)\right)$$

(4)

Here, $\wedge$ and $\vee$ are the symbols of the logic operators MIN and MAX, respectively, but the indexes below indicate that these operators refer to different subsets. For simplicity, we consider here the calculation of operator supremum as a version of the MAX operator [46], taken with some additional limitations. Exps. ${\mu }_{a_{pj}}\left(x_j\right)$ are MFs of antecedents in “If …Then…” rules, index $p$ shows the number of the fuzzy rule, where $p\in P$ = {1,…,P}, x_j are input variables, where $x_j\in X_j$ = {1,…, X_j}. Moreover, input variables are tagged by indexes $j\in J$ =$\{1,\dots ,$ J $\},$ output variables are indicated by indexes $k\in K$ =$\{1,\dots ,$ K}$.$ In exp. (4) ${\mu }_{a_j^{*}}\left(x_j\right)$ tags MFs for approximate values of input variables of the antecedent, and MFs ${\mu }_{b_{ik}^{*}}\left(y_k\right)$ respond to consequences in “IF …Then…” rules. Exp. (4) describes MFs with arbitrary profiles but obligatory convex and normalized to 1 [33,46].

Within the presented paper, we discuss only the control via parametrical gates with simple triangular MFs and the regulating parameter $m$. $T$-norms and $T^{*}$-conorms, which are the wider class of operators than traditional MIN/MAX gates, are considered further as extensions or replacements for basic $\wedge$ and $\vee$ operations in exp. (4), namely to verification procedures. Thus, the detailed discussion of the possible influence of quantum signals on all control procedures in FLC is outside the scope of this paper.

For confidential regulation of controllers by quantum signals, it is more convenient to use only some of the $T$-norms/$T^{*}$-conorms given in

Table 1. T-norms/T*-conorms considered in [12,23,24,26,27,28,33,34,46].

Author	Norm T(x,y)	Conorm T*(x,y)
L. Zadeh	MIN (x,y)	MAX (x,y)
Goguen	xy	x + y − xy
-	xy/(x + y − xy)	(x + y−2xy)/(1 − xy)
Giles	MIN (x + y, 1)	MAX (x + y−1,0)
-	(lxy/(1 − (1 − l) (x + y − xy))	l(x + y) + xy(1−2l)/l + xy(1 − l))
-	mxy/(1 − (1 − m)(x + y − xy)	(m(x + y) + xy(1−2m))/(m + xy(1 − m))
-	MIN (x + y + mxy,1)	MAX ((1 + m)(x + y-1) − mxy,0)
Weber	MIN (x + y + mxy,1)	MAX ((x + y − 1 + mxy)/(1 + m),0)
Yandong	MIN (x + y + mxy,1)	MAX ((1 + m)(xy − 1) − mxy,0)
Schweizer and Sklar, p ∈ (−∞,+∞)	1 - max [0, (1 − x) –p + (1 + y)–p − 1)] 1/p	MAX (0, x−p + y–p − 1) −1/p
Hamacher,$m \in \left[0,+\infty \right)$	xy/(m + (1 − m)(x + y − xy))	(x + y − (2 − m) xy)/xy(1 − (1 − m)xy)
Frank, s ∈ (0,+∞)	1 − logs [1 + (s 1-x − 1)(s1 - y − 1)/s − 1]	logs [1 + (sx − 1)(sy − 1)/s − 1]
Yager, w∈(0,+∞)	MIN [1, (xw + yw)1/w]	1 − MIN [1,(1 − x)w + (1 − y)w)1/w
Dubois and Prade, α∈ (0,1)	X + y − xy − MIN(x,y,1 − α)/ MAX (1 − x,1 − y, α)	ab/MAX (x,y,α)
Dombi, λ ∈ (0,+∞)	1/1 + [(1/x − 1)-λ + (1/y − 1) −λ ] −1/λ	1/1 + [(1/x − l)λ + (1/y − 1)λ]1/λ

.

Table 1 contains an analytic description of the most popular operators, e.g., those proposed by Zadeh, Frank, Weber, Yandong, and Hamacher. The variety of such triangular norms and conorms gives the possibility to choose the most adequate variant for the joint processing of classical and quantum signals, and we will use only the pair of $T$-norms and $T^{*}$-conorms proposed by Hamacher [35] due to several reasons discussed further.

Hamacher operators [35] use the simplest arithmetic operations and linear parameters without exponentiation, such as Frank’s or Yager’s operators. Moreover, Hamacher gates are more interesting for us, as they can be easily calculated by mass-produced microcontrollers. One linear parameter $m$ is given by a natural number and can be used as a separate continuous or discrete “switcher” in the fuzzy controller applied to the agent.

Furthermore, traditional MIN/MAX operators are less comfortable with the verification channel and quick re-switching of variables and fuzzy gates in critical situations. It is easier to transfer one confidential instruction to change $m$ in $T$-gate, than to describe what variables and gates in the fuzzy inference scheme should receive the confidential instruction in all necessary modules. The expected gain here is the simplification of algorithms for verification and crisis control.

Thus, instead of operators MIN/MAX, where $x_1,x_2,$ are input variables, one should use the gate $F\left(x_1,x_2,m\right)$ in modules of the agent, using quantum data. The emulation of Hamacher logic gates can be performed with the help of the analytical expressions in Table 1.

For the proposed further method of practical applications, one should calculate a more detailed version of

Table 2. Symmetrical values of Hamacher’s $T$-norm $T\left(x_1,x_2,m\right)$, shown for the regulating parameter $m=0, 5$ and 10 gradations of input variables $x_1$,$x_2$.

	X2	0.1	0.2	0.3	0.4	0.5	0.6	0.7	0.8	0.9	1.0
X1
0.1		0.0168	0.0313	0.0437	0.0547	0.0645	0.0732	0.0809	0.0879	0.0938	0.1
0.2		0.0313	0.0588	0.0833	0.1053	0.1250	0.1428	0.1590	0.1739	0.1875	0.2
0.3		0.0437	0.0833	0.1192	0.1518	0.1818	0.2093	0.2346	0.2580	0.2798	0.3
0.4		0.0547	0.1053	0.1518	0.1951	0.2352	0.2727	0.3077	0.3404	0.3711	0.4
0.5		0.0645	0.1250	0.1818	0.2352	0.2857	0.3333	0.3784	0.4211	0.4615	0.5
0.6		0.0732	0.1428	0.2093	0.2727	0.3333	0.3913	0.4468	0.5000	0.5510	0.6
0.7		0.0809	0.1590	0.2346	0.3077	0.3784	0.4468	0.5130	0.5773	0.6396	0.7
0.8		0.0879	0.1739	0.2580	0.3404	0.4211	0.5000	0.5773	0.6531	0.7273	0.8
0.9		0.0938	0.1875	0.2798	0.3711	0.4615	0.5510	0.6396	0.7273	0.8140	0.9
1.0		0.1	0.2	0.3	0.4	0.5	0.6	0.7	0.8	0.9	1.0

, briefly demonstrating the symmetric structure of Hamacher’s $T$-norm taken, e.g., for only one value $m=0,5$ and 10 gradations of $x_1,$ and $x_2$. Note that input variables in the Hamacher gate may have truth levels $x_1,x_2$∈[0,1], but parameter $m$∈[0,+∞) can be infinite, where the positive sign for $m$ values gives an additional advantage for microcontrollers. The proper choice of parameter $m$ provides the possibility to adjust the precision of data to an 8–16-bit format. The number of grades for emulation of $T$-gates in real systems is limited by the throughput of 8–16 bit and higher platforms.

One additional argument to apply, namely Hamacher gates, is their more frequent use in recent papers such as [37], devoted to hesitant fuzzy linguistic aggregation operators. As this operator is more convenient for modern extended modeling, it may have some additional advantages for more complicated procedures.

However, if one compares logic models from Table 1 with the help of MATLAB products, it will be revealed that Hamacher’s model will give more drastic changes in the surface shape than, e.g., Weber’s and Yandong’s ones for the same increment of the parameter $m$. As in fuzzy logic, greater values of membership function $\mu \left(x\right)$ respond to a greater level of possibility, so Hamacher’s model gives a more drastic and “optimistic” estimation, while the other two mentioned above refer to more pessimistic estimates. Such specifics should be taken into account for the choice of parameter $m$ in Hamacher gates, which are used for drastic re-switching or “almost blocking” of the system but may not be good for non-linear performance characteristics as in FFOPID [31,32]. Respectively, our current accent on Hamacher gates is motivated mainly by control scheme simplification and should be attentively adjusted for specific controllers.

But namely, the interest in modern network small- and middle-scale agents for IoT and IoV induces the discussion of the question, how multi-parametric MVL modeling [9,13,18] can enhance the possibilities of $T$-gates.

2.2. MVL Modelling

A detailed description of further Allen–Givone algebra (AGA) can be seen in Open Access papers [9,13,18]. AGA is the discrete model [38], which uses its specific tools. AGA function $y=f\left(x_1,\dots ,x_n\right)$ can be given for $n$ input variables $x_1,\dots ,x_n$ and one output variable $y$, which may have $k$ discrete truth levels, i.e., $x_1, x_2 ,\dots ,x_n ,y\in L=\left\{0,1,\dots , k-1\right\}$. The complete set of operators

$$\langle 0, 1,\dots , k-1, X\left(a,b\right), \wedge , \vee \rangle$$

(5)

includes logic constants, binary operators MIN($x_i,x_{j }$) tagged by $(\wedge$), MAX($x_i,x_{j }$) tagged by ($\vee$), and the unary operator Literal $X\left(a,b\right)$

$$X\left(a,b\right)=\{\begin{array}{c}0,if b<x<a\\ k-1, if a\le x\le b ,\end{array}$$

(6)

where for any $X\left(a,b\right)$ always $b\ge a,$ and $a,b \in L=\left\{0,1,\dots ,k-1\right\}.$ Note that, as commented earlier in Section 2.1, operators MIN and MAX should do just the same procedures, but for the more limited class of sets called membership functions. In theory, in fuzzy logic, these operators should process an infinite number of truth levels, but in reality, 8- or 16-bit emulations of fuzzy MFs make the MIN and MAX operators in fuzzy logic just the same as in the discrete AGA logic model. That is the additional stimulus to find unified schemes for joint application of fuzzy logic with MVL models [9,13], using the large number of truth levels.

The complete set of operators Equation (5) guarantees the design of correct formal models for any arbitrarily given function $y=f\left(x_1,\dots ,x_n\right)$, including the emulation of $T$-norms and $T^{*}$-conorms written in an appropriately given truth table.

Any function in AGA given by the MVL truth table [38] can be represented by Equation (7):

$$\begin{array}{c}F\left(x_1,\dots , x_n\right)=F\left(0,0,\dots ,0\right)\wedge X_1\left(0,0\right)\wedge \dots \wedge X_n\left(0,0\right) \vee \\ F\left(0,0,\dots ,1\right)\wedge X_1\left(1,1\right)\wedge \dots \wedge X_n\left(0,0\right)\vee \end{array}$$

(7)

$$\vee F\left(k-1,k-1,\dots ,k-1\right)\wedge X_1\left(k-1,k-1\right)\wedge \dots \wedge X_{jn}\left(k-1,k-1\right),$$

where constants $F\left(0,0,\dots ,0\right)$ are the non-zero values of output functions taken for the set of input values $0,0,\dots ,0$ and further, and product terms such as $X_1\left(0,0\right)\wedge \dots \wedge X_n\left(0,0\right)$ and further should have equal values $a=b$ of Literals, taken for corresponding values of input variables.

Some limitations for the practical use of AGA are the minimization procedure [38], which is necessary for shortening the number of product terms and making faster calculations. Such functions can be easily minimized for a limited number of input variables or for specific data sets. This procedure is accompanied by the modification of parameters $\left(a,b\right)$ in Literals $X\left(a,b\right)$.

The above brief description of AGA provides the possibility of modeling $T$-operators in heterogeneous logic schemes and verification procedures.

3. Results: Parametrical Logic Gate as the Tool for Confidential Control of Classical Signals by Quantum Data

Autonomous robotic applications of quantum keys are mainly associated with wireless QKD lines, whose application should take into account some specifics for distant agents. As an agent’s subsystems can contain confidential commercial data, which may be disclosed during distant verification or correction of control procedures, a multi-agent system should include some additional protocols to deliver requested confidential data from each of the subsystems of the agent $A_1$ to the distant agent $A_0$, or to compare distantly the identity of these data. So that the task is to somehow protect all possible subsystems in case of extraordinary situations, which are rare enough. However, even for such events, it is preferable to use fragmented one-time quasi-random keys [9,13,18], which were not yet used by the main communication module of the agent. Some of these aspects were partially discussed in [13,18] concerning the MVL version of the blockchain-type scheme of the linked list for collective data protection in network agents. These schemes were based on quantum quasi-random keys.

Certainly, specialized modules for network communications in the agent should use full-scale cryptography tools [12], but scarcely one can equip every internal subsystem with the software for secret coding, as it is an expensive tool. Although some data from internal subsystems may be deliberately requested to be transferred to a distant supervisor, full-scale cryptography software may be excessive here. Principally, AI verification procedures for autonomous IoT robotics suppose minimalistic traffic and brief instructions/replies, but not long altercations between the admin and the distant home robot. Respectively, light-protected coding with short enough procedures is also necessary for deliberate, urgent verification of agents in the IoT.

3.1. Confidential Parameter Transfer by Means of Quantum Keys and Simplified Sectret Coding

As it follows from detailed reviews [48,49], traditional QKD schemes provide the distribution of keys, and the direct transfer of messages by qubits is not used in practice. This is due to the fact that the efficiency of quantum key generation is determined by the number of bit errors in the QKD line, which is not a constant and strongly depends on the attenuation coefficient for single photons in the transmitting line [12]. Namely, all kinds of this attenuation limit the overall efficiency of the quantum key generation and enlarge the part of the raw key that is to be used for obligatory sifting, error correction, and privacy amplification of the processed key [48,49]. Thus, key generation is a complicated procedure itself, which influences the number of errors to be corrected in transmitted messages, which is critical for intensively coded traffic. However, for modern QKD lines with an enlarged key generation rate and already well-formed key processing procedures, one may use preliminary written quantum keys. Such procedures in the case of failures and faults may be very useful, but they are regarded as rare events.

Let us consider, as shown in Figure 3, the network supervisor agent $A_0$ and its distant partner agent $A_1$, which exploit the wireless QKD system with abonents Alice and Bob [12,48,49], exploiting obligatory quantum and classical data channels with supporting modules. The generated key with the length $L$ is further fragmented into 8-bit parts, as in the MVL version of the blockchain scheme for network agents [13,18]. Some of these fragmented, high-quality keys should be taken from the specially formed list for data verification and restoration.

If $A_0$ needs to activate the verification or data correction procedure in $A_1$ remotely, the special instructions should be sent via the network communication module. Then quasi-random keys generated by the QKD line can be used, which are known only to the sender and the receiver due to the non-cloning theorem [44]. The set of quasi-random bits in the chosen 8-bit fragment of the key contains almost equal numbers of 0 s and 1 s, which is confirmed by one of the corresponding basic tests provided by the NIST set of protocols for cryptography designs [50]. The method to prepare such short keys can be based on any method of sequential fragmenting of the key into bytes, as some of the obligatory cryptography NIST tests guarantee a close to uniform distribution of 0 s and 1 s with a low probability of deviations. Keys can be generated beforehand during the service session of the robot and written in the special list, where numbers of keys respond to addresses in static random-access memory (SRAM).

An alternative variant for light IoT cryptography is the application of the version of random oracle scheme (RO) [51], which can be based on AGA functions and was initially proposed for the position-based cryptography protocol [13,16], using entangled photon pairs. Moreover, such a scheme of RO was proposed to be used in the MVL linked list [18] for robotic backup network storage in loyal network nodes.

In fact, RO [51] is the microcontroller with a large enough SRAM memory and specially composed AGA software, which can be learned by a quantum random number generator (QRNG) [17]. The input of an arbitrary quasi-random number into RO will lead to the output of the quasi-random value of the hash function with the fixed length of the output variable. The principal difference between QRNG and RO is the reproducibility of output data for repeated inputs. Hash values should also satisfy some demands for the quality of quasi-random numbers. Principally, RO-type devices are well known in robotics, but usually the requirements for them are not very high.

However, such a scheme is a good candidate to provide autonomous agents with quasi-random keys without a QKD line. If equal copies of RO are installed in collaborating agents within the trusted service zone and the agent scheme is specially designed, then a high enough level of confidentiality can be provided even without expensive QKD lines, and agents may also use quasi-random keys for the simplified coding by $T$-norms and $T^{*}$-conorms. The numbered list of secret keys in RO is to be copied into a pair or several agents and should be refilled periodically.

Distant verification or comparison of data in IoT devices is still possible without traditional cryptography protocols such as Advanced Encryption Standard (AES) and the one-time cipher pad method [12], as well as without the MVL secret coding scheme [45]. Such a scheme is proposed in

Table 3. Confidential data transfer via the non-protected line by disclosing the number of the secret key in the shared list.

	Alice	Bob
Task:	To send confidential byte, e.g., $d_i=\#10001110$ to Bob
Coding resource: Equal sets (or the numbered list) of common quasi-random keys.	${\underset{\_}{k}}_1$ = 11001011, ${\underset{\_}{k}}_2=01011100$, ${\underset{\_}{k}}_3=10010111$, …	${\underset{\_}{k}}_1$ = 11001011, ${\underset{\_}{k}}_2$ = 01011100, ${\underset{\_}{k}}_3$ = 10010111, …
Steps:	Alice	Bob
1. To write consecutive numbers of positions $Poz$ for bits in ${\underset{\_}{k}}_1$, ${\underset{\_}{k}}_2,$…, which coincide with bits in $d_i$	Compares: di = 10001110 with ${\underset{\_}{k}}_1$ = 11001011, ${\underset{\_}{k}}_2$ = 01011100, … Result: In ${\underset{\_}{k}}_1$:Poz = 1,3,4,6; In ${\underset{\_}{k}}_2$:Poz = 2,4,5,7.	-
2. Transfer to Bob	$N_{{\underset{\_}{k}}_1}$: 1,3,4,6; $N_{{\underset{\_}{k}}_2}$: 2,4,5,7	-
		$N_{{\underset{\_}{k}}_1}$: 1,3,4,6; $N_{{\underset{\_}{k}}_2}$: 2,4,5,7
3. Reconstruction of confidential byte	-	${\underset{\_}{k}}_1$= 1 1 0 0 1 0 1 1,   ↓  ↓↓  ↓   1 0 0  0     ${\underset{\_}{k}}_2$=0 1 0 1 1 1 0 0       ↓ ↓ ↓  ↓       1 1 1  0 Finally, di = 10001110

. Abonents Alice and Bob are supposed to have equal lists of earlier, non-used secret keys $\underset{\_}{k}$. Here $d_i$ is the byte that is to be confidentially transferred, and ${\underset{\_}{k}}_1$,…, ${\underset{\_}{k}}_K$ are fragmented quasi-random keys with a length of 1 byte. The sender of the message discloses which bits in the secret key with the number N coincide with the bits in the confidential byte.

The sender of the message should prompt the implicitly necessary 0 s and 1 s in the verified confidential byte. Poz is the sequential position of the bit in the corresponding confidential key ${\underset{\_}{k}}_1$,…, ${\underset{\_}{k}}_K$, which coincides with the original bit in the $d_i$. Then $A_0$ should only transfer the sequence of Poz values and numbers of several used keys in the list ${\underset{\_}{k}}_1$,…, ${\underset{\_}{k}}_K$, in order to give Bob the opportunity to reconstruct the secret byte. Principally, here we should not limit the number of necessary procedure keys, although based on NIST tests, one can expect that the necessary number of these keys would scarcely exceed twice the length of the confidential data set. NIST tests [50] guarantee that the number of 0 s and 1 s in blocks will not differ greatly from some value determined by the probability of the bit error, so that twice the key length is expected to be enough.

Certainly, for a short data sequence, the eavesdropper may simply try to guess bits, but here the obvious protection step is to deliberately enlarge the number of confidential bits by some additional quasi-random hashing function, which can also be realized by means of the additional hashing procedure using the RO scheme based on the MVL algorithm [51]. A detailed discussion of this method is outside the scope of this paper. The only limitation here is that the time of calculation will also be enlarged, but on the other hand, the actual time of secret data should be less than the time of its hacking.

In particular, the proposed above procedure can distantly transfer the confidential value of the regulating parameter $m$ of $T$-gates, which is used to re-switch the controller. Then parametrical logic gates [12,26,35] can be used as a universal tool for confidential data control and verification.

3.2. Comparison of Confidential Data without Their Disclosing, Based on $T$-Norms and $T^{*}$-Conorms

If agents $A_1$ and $A_2$ were loaded by keys by means of the QKD line, see Figure 3, or copied one version of RO [51] in the trusted zone, as shown in Figure 4, then they could distantly compare confidential data bytes without its disclosure. The model task is to verify confidentially if both versions of some input variable $x_1$, or of a control parameter $m$, used in $T$-norms/$T^{*}$-conorms, are equal. Say, $A_1$ has the version $m^{\left(1\right)},$ and $A_2$ has its version $m^{\left(2\right)}$. In fact, verification should not estimate the reason for the discrepancy but reveal the fact of non-identity and activate the restoration of data with the help of distributed backup storage using the blockchain scheme of the linked list written in loyal network nodes [13,18]. The procedure for the secret verification of $m$ by means of $T$-norms and $T^{*}$-conorms calculations is given in Figure 5.

In Figure 5, agents $A_1$ and $A_2$ are equipped with identical copies of RO and use the parameter $m$ as the regulating parameter in $T$-gates taken as Hamacher function T($x_1,x_2,\mathrm{m}$). Here, subroutines reproducing $T$-gates from Table 1 can be involved.

Calculations in Agents 1 and 2 for the realization of

Table 4. The procedure to compare versions of the confidential parameter $m$, written by two collaborating agents without disclosing this parameter.

	Input: ← List of quasi-random keys from QKD line or copies of RO in both agents
	Agent 1	Agent 2
1.	$\mathrm{Chooses} \mathrm{randomly} N_1^{\left(1\right)}$$, N_2^{\left(1\right)}$,	-
2.	Calculates T$(\underset{\_}{k}\left(N_1^{\left(1\right)}\right), \underset{\_}{k}\left(N_2^{\left(1\right)}\right), m^{\left(1\right)})$	-
3.	$\mathrm{Transfers} N_1^{\left(1\right)}$$, N_2^{\left(1\right)}$, and T$(\underset{\_}{k}\left(N_1^{\left(1\right)}\right), \underset{\_}{k}\left(N_2^{\left(1\right)}\right),m^{\left(1\right)})$ to Agent 2	-
4.	-	$\mathrm{Chooses} \mathrm{randomly} N_1^{\left(2\right)}$$, N_2^{\left(2\right)}$,
5.	-	$\mathrm{Calculates} T(\underset{\_}{k}\left(N_1^{\left(2\right)}\right), \underset{\_}{k}\left(N_2^{\left(2\right)}\right),m^{\left(2\right)})$
6.	-	$\mathrm{Transfers} N_1^{\left(2\right)}$$, N_2^{\left(2\right)}$, and T$(\underset{\_}{k}\left(N_1^{\left(2\right)}\right), \underset{\_}{k}\left(N_2^{\left(2\right)}\right),m^{\left(2\right)})$ to Agent 2
7.	$\mathrm{Restores} \mathrm{value} m^{\left(2\right)}$	$\mathrm{Restores} \mathrm{value} m^{\left(1\right)}$
	$\mathbf{Output}: \mathrm{confidential} \mathrm{data} m^{\left(1\right)}, m^{\left(2\right)}$ for comparison are in Agents 1 and 2

are proposed to be based on some realization of the RO module in order to use the most secure one-time random keys discussed in [45,51]. When the agent uses RO, it should substitute the randomly chosen input number N as an address # into the memory chip, containing a preliminary generated list of specially processed random hash values. The memory device will output the corresponding hash value (i.e., the key) k(N) to be used further for confidential data transfer and comparison of internal parameters without their disclosure. Agent 1 has the version $m^{\left(1\right)}$ and Agent 2 has the version $m^{\left(2\right)}$ of the same parameter m, which may differ due to errors or illegal modifications. The whole procedure responds to Table 4.

In order to compare versions of $m$, each agent randomly chooses two numbers, taken from the list of quasi-random keys, and substitutes them into T($x_1,x_2,\mathrm{m}$) as input variables $x_1,x_2 .$ $A_1$ has chosen some numbers $N_1^{\left(1\right)},N_2^{\left(1\right)} ,$ and $A_2$ has taken $N_1^{\left(2\right)},N_2^{\left(2\right)}$. These numbers are necessary to obtain secret keys $\underset{\_}{k}\left(N_1^{\left(1\right)}\right),$ $\underset{\_}{k}\left(N_1^{\left(2\right)}\right),$ $\underset{\_}{k}\left(N_2^{\left(1\right)}\right),$ in Table 4. According to it, Agent $A_1$ sends $N_1^{\left(1\right)}$,$N_2^{\left(1\right)}$, and T($\underset{\_}{k}\left(N_1^{\left(1\right)}\right), \underset{\_}{k}\left(N_2^{\left(1\right)}\right),m^{\left(1\right)})$ to $A_2$; then $A_2$ replies with values $N_1^{\left(2\right)}$,$N_2^{\left(2\right)}$, and T($\underset{\_}{k}\left(N_1^{\left(2\right)}\right), \underset{\_}{k}\left(N_2^{\left(2\right)}\right), m^{\left(2\right)})$. Then the calculation of the Hamacher expression for $T$-norm (or $T^{*}$-conorm) according to Table 1 can provide all necessary data for the reconstruction of $m^{\left(1\right)},$ and $m^{\left(2\right)}$ by both agents.

Both Agents 1 and 2 are supposed to have identical copies of RO data sets, and their versions of $m^{\left(1\right)}$ and $m^{\left(2\right)}$ are to be compared. Let us suppose that $m^{\left(1\right)}=m^{\left(2\right)}$ = 255 in the decimal format (DEC) or 11111111 in the binary format (BIN). The number of bits for versions of $m$ corresponds to the format of $N_1^{\left(1\right)},N_2^{\left(1\right)}, N_1^{\left(2\right)},N_2^{\left(2\right)},$ and resources of the microcontroller. Principally, the proposed above algorithm involves the use of a random number generator for the random choice of $N_1^{\left(1\right)},N_2^{\left(1\right)} ,$ and $N_1^{\left(2\right)},N_2^{\left(2\right)}$, but in practice, one can periodically write the necessary amount of random numbers beforehand, besides the set of random keys ${\underset{\_}{k}}_1=11001011$, ${\underset{\_}{k}}_2=01011100$, ${\underset{\_}{k}}_3=10010111$, …. In the common case, the number of bits for $N$ and $\underset{\_}{k}$ values should be preferably different for the sake of data protection, but the discussed algorithm itself does not create any limitations here, and for simplicity, we consider a further 8-bit format both for the input and the output signals of RO.

As it was mentioned above, RO module [51] is an SRAM chip with specially prepared random data, which, e.g., for an arbitrarily given input 8-bit address #, say, number 10011001(BIN), will output 8-bit number $N_1^{\left(1\right)}=$ 01110010(BIN) = 114(DEC). Further, one can generate the second necessary value, e.g., $N_2^{\left(1\right)}=$ 11001011(BIN) = 203(DEC). Then the calculation of T($\underset{\_}{k}\left(N_1^{\left(1\right)}\right), \underset{\_}{k}\left(N_2^{\left(1\right)}\right), m^{\left(1\right)})$ should be based on Hamacher gates $T^{*}$-conorm=($x_1$ $+$ $x_2-$ ($2-$ $m$)$x_1{x}_2)/x_1{x}_2\left(1-\left(1-m\right) x_1{x}_2\right),$ or $T$-norm =$x_1{x}_2/\left(m+\left(1-m\right)\left( x_1+x_2-x_1{x}_2\right)\right),$ including variables $x_1$,$x_2$, and $m$ as input ones. As the calculation of $T$-norm requires fewer multiplication operations than the conorm, it is simpler to use, namely on simple microcontroller platforms. Then the substitution of arguments $m^{\left(1\right)}=11111111$ and $x_1=01110010$, $x_2=11001011,$ taken as two different values $k\left(N\right),$ will need to calculate the sequence of arithmetic operations according to expression $T$($\underset{\_}{k}\left(N_1^{\left(1\right)}\right), \underset{\_}{k}\left(N_2^{\left(1\right)}\right), m^{\left(1\right)})=$ $x_1{x}_2$/(m + (1–m)($x_1$ + $x_2$ – $x_1{x}_2$). The substituted value of $T$-norm will give the version of $m$ of the partner agent.

The calculation of e.g., the first multiplication operation will give:

$x_1{x}_2=114\times 203=23142$(DEC)$= 0101101001100110$(BIN), which is to be continued by other arithmetic procedures used in $T$-norm. One should especially note that 16-bit calculations are to be held here by means of the 8-bit controller with its standard arithmetic operations; such software is described, e.g., for 8-bit MCS−51 in [52]. Such a program will need approximately twice the number of operators in microassembler code and an enlarged memory resource. The most difficult question here is the precision of division procedures provided by the simplest controllers. That is why Hamacher norms calculations seem to be more efficient for field-programmable gate arrays (FPGA) [53]. Nevertheless, not all intensive data checks and recovery tasks may use even 8-bit controllers.

The restoration of the partner’s Agent 2 version of $m^{\left(2\right)}$ may be calculated according to the linear Equation (8), obtained just from Hamacher’s $T$-norm:

$$m^{\left(2\right)}=\frac{\left(x_1{x}_2\right)/T-\left( x_1+x_2-x_1 x_2\right)}{1-\left(x_1+x_2-x_1 x_2\right)}$$

(8)

where $T$ is the received value of $T$($\underset{\_}{k}\left(N_1^{\left(2\right)}\right), \underset{\_}{k}\left(N_2^{\left(2\right)}\right),m^{\left(2\right)})$ from Agent 2.

One should note that in order to exclude the probability of guessing bits in short data sequences, e.g., with the length of 1 byte of the number $m$, one can use an additional hashing function, enlarging the length of $m$ from one into several bytes. Then additional pairs of keys from the list of keys or from RO will be necessary to transfer the secret byte to the partner agent. Such a version of light cryptography for agents can be realized in microcontroller subsystems by basic embedded arithmetic operations.

However, besides confidential verification procedures, $T$-gates can potentially also be used for confidential quantum data switching of the agent’s functions, which need to emulate such $T$-gates by unified AGA methods capable of providing the whole set of earlier proposed verification and intellectual procedures [9,16,18,45].

3.3. MVL Emulation of T-Gates for Controllers

Confidential re-switching of FLC by a quantum signal without the application of a quantum memory device supposes some classical measurements of qubits, such as in protocols [45,48,49], and the further input of the result into a separate classic switching channel. Such a channel should exclude external access to hardware modules and software procedures. $T$-gate here is the possible candidate for such isolated switching channels, as the regulating parameter $m$ can be directly transferred by the quantum channel or can be calculated by routine procedures. Principally, it does not need obligatory interaction with the MVL processing platform and can use the Boolean one, but earlier proposed MVL schemes for data coding and verification [9,13,16,45] can give additional attractive options for robotic applications.

In order to design a discrete AGA analog of an FLC with an additional channel for quantum control, it is necessary to choose operators and input variables. Principally, a complete analysis of possible applications for $T$-norms/$T^{*}$ conorms should include all operators in Equation (4), but the initial design should be concentrated on the fragment ${\mu }_{a_{ij}}\left(x_j\right)\wedge {\mu }_{a_j^{*}}\left(x_j\right)$ of logic Equation (4), which “compares” the fuzzy template MF μa_ij(x_j) of the antecedent and the MF of measured data ${\mu }_{a_j^{*}}\left(x_j\right)$ by means of the gate MIN (∧). Thus, instead of gate MIN (x₁, x₂), one should use the gate $T\left( x_1,x_2,m\right)=\frac{ x_1{x}_2}{\mathrm{m} +\left(1–\mathrm{m}\right)\left( x_1+x_2 – x_1{x}_2\right)},$ containing: (1) regulating parameter (variable) $m,$ (2) the template MF μa_ij(x_j) substituted as $x_{1 },$ and (3) the approximate measurement result MF ${\mu }_{a_{ij}^{*}}\left(x_j\right)$, taken as $x_2$. Such model provides enough flexibility, as in the simplest version, one can choose ${\mu }_{a_{ij}^{*}}\left(x_j\right)=x_j$, but for better precision, some profiles can be taken.

The model of the fuzzy controller shown above in Figure 2, which responds to the homeostatic principle and imitates the electromotor stabilization task, is considered the most typical variant to be emulated by the AGA function. The fuzzy logic model here describes separate template MFs for input and output variables, given in Figure 2 as cases (c) and (d). The first step here is to reproduce triangular membership functions $\mu \left(x\right)$ for linguistic values $n, z,p$ of the linguistic variable $x$ used in Figure 2c, corresponding to typical characteristics “negative”, “zero”, and “positive” in the task, to stabilize the value of $x$ close to 0.

The simplified emulation of such a model is represented in Figure 6a,b, where input variables “error” $x_{err}$ and “derivative of error” are shown as stepped curves.

An obligatory step here is to carry out preliminary mapping of the scale [–1,1], used for physical input variables in Figure 2c, into the scale of truth levels [0,255], used in Figure 6 for the AGA model. Principally, such mapping can also be non-linear if necessary. The only limitation here is choosing its expression easily enough for reverse mapping and data restoration. The green step curve $T_1$ and $T_3$ imitates the linear segment of the membership function “negative” $n$ in Figure 2; blue step curve $T_2$ and $T_2$ are the analogs of the curve “positive”$p$ in Figure 2. Curve “zero” is excessive here for the AGA model, as it does not exploit the concept of fuzzy numbers [23,33]. But $T_1$ and $T_2$, as well as $T_3$ and $T_4$ curves, are quite enough to reproduce the necessary control signal, which should be maximal for large deviations from zero, and almost zero for values of x close to zero. The number of discrete steps in Figure 6 is taken to be equal to 6 for simplicity, as it is principally limited only by the throughput of the microprocessor. At the same time, this number overlaps 5 linguistic output values in Figure 2d. Moreover, for the initial formal modeling, one can define the MVL function with k = 256 truth levels, but to use firstly only 5 or 10 gradations of input variables, and further enlarge the complexity and the number of involved gradations. Note that the 256 gradations of the 8-bit platform and $k=256$ truth levels in AGA algebra entirely overlap the typical precision level of many FLCs.

However, some specifics of AGA calculus should be taken into account, concerning the choice of template MFs μa_ij(x_j). The FLC model in Figure 2c,d can process negative values, but AGA intrinsically defines all variables as natural numbers. The most simple and obvious way to use AGA here is to define two separate variables $x_{err}{}^{+}$ and $x_{err}{}^{-}$ for positive and negative values of the linguistic variable $x_{err}$, as well as two variables $x_{derr}{}^{+}$ and $x_{derr}{}^{-}$ + for the linguistic variable $x_{derr}$.

After this, one can sequentially form, e.g., the “positive” fragment of the logic function $F\left(x_{err}, x_{derr},m\right),$ using logic constants directly taken from Figure 7. Here, corresponding truth levels are written in steps of the curve $T_2$, given for variable $x_{err}$.

The correlation between positive and negative linguistic values of variables $x_{err}$ and $x_{derr}$ can be taken into account as follows. The measured classic value of the sensor can be either positive or negative, which is why in the product term either $x_{err}^{-}$ should be 0 and $x_{err}^{+}$ non-zero, or just the reverse. The following also refers to $x_{derr}$.

According to exp. (4), the AGA model of FLC with T-gates should sequentially calculate the fragment ${\mu }_{a_{ij}}\left(x_j\right) \wedge {\mu }_{a_j^{*}}(x_j$) for variables ${\mu }_{err}^{+}$, ${\mu }_{err}^{-}$, ${\mu }_{derr}^{+}$, ${\mu }_{derr}^{-}$. For the “positive” curve $T_2$ in Figure 7 (corresponding to the variable ${\mu }_{err}^{+}$), the equivalent logic expression taken with the parameter $m=m_1$ and omitted measurement results in Literal $X_{*err}\left(\dots ,\dots \right)$, can be written as Equation (9):

$$\begin{array}{l}{F}_{T2}({\mu }_{err}^{+}, {\mu }_{err }^{*},m_1)=,\\ 1\wedge X_{+err}\left(140, 160\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 2\wedge X_{+err}\left(160, 180\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 3\wedge X_{+err}\left(180, 200\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right) \vee \\ 4\wedge X_{+err}\left(200, 220\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 5\wedge X_{+err}\left(220, 240\right)\wedge X_{*err}(\dots ,\dots \wedge X_m\left(m_1,m_1\right))\vee \\ 6\wedge X_{+err}\left(240, 255\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right).\end{array}$$

(9)

The chosen Literals parameters in $X_m\left(m_1,m_1\right)$ can be explained by the fact that, according to the rules of AGA function formation [38], equal parameters $a=b$ in $X\left(a,b\right)$ means that Literal function exp. (6) is non-zero only for the value $m_1.$ Respectively, notation $X_{+err}\left(220, 240\right)$ in the product term with constant 5 means that the “positive” linguistic value of the variable $x_1$ gives a non-zero Literal for the band of values $x_1$∈[220,240].

For the “negative” curve $T_1$ the variable ${\mu }_{err}^{+}$ with parameter $m=m_1$ and omitted measurement result, the corresponding logic expression can be written as Equation (10):

$$\begin{array}{l}{F}_{T1}(m_1, {\mu }_{err}^{-}, {\mu }_{err}^{*})=\\ 1\wedge X_{-err}\left(0,20 \right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 2\wedge X_{-err}\left(20,40\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 3\wedge X_{-err}\left(40,60\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 4\wedge X_{-err}\left(60,80\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 5\wedge X_{-err}\left(80,100\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 6\wedge X_{-err}\left(100,120\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right). \end{array}$$

(10)

The resulting expression for both linguistic values of $x_{err}$ can be formed as

$$\begin{array}{l}{F}_{err}=\\ 1\wedge X_{+err}\left(140, 160\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 2\wedge X_{+err}\left(160, 180\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 3\wedge X_{+err}\left(180, 200\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 4\wedge X_{+err}\left(200, 220\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 5\wedge X_{+err}\left(220, 240\right)\wedge X_{*err}(\dots ,\dots ) \wedge X_m\left(m_1,m_1\right)\vee \\ 6\wedge X_{+err}\left(240, 255\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 1\wedge X_{+err}\left(140, 160\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 2\wedge X_{+err}\left(160, 180\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 3\wedge X_{+err}\left(180, 200\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 4\wedge X_{+err}\left(200, 220\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right)\vee \\ 5\wedge X_{+err}\left(220, 240\right)\wedge X_{*err}(\dots ,\dots ) \wedge X_m\left(m_1,m_1\right)\vee \\ 6\wedge X_{+err}\left(240, 255\right)\wedge X_{*err}\left(\dots ,\dots \right)\wedge X_m\left(m_1,m_1\right). \end{array}$$

(11)

Do not forget that “$\vee$” means here AGA’s operator MAX, as we model fuzzy calculations by means of discrete AGA calculus!

The simplification of exp. (10) by means of AGA minimization and the consensus method [38] is not reasonable here, as for both linguistic values, groups of non-zero-product terms with different constants are located far away from each other in the three-dimensional space. Principally, some minimization procedure could make sense for a real FLC with some fixed, uneven spectrum of measured values of $X_{*err}$.

The formation of the AGA expression for the derivative variable $X_{derr}$ is analogous to the proposed above procedure for $X_{err}$, as stabilization curves $T_{3 }$ and $T_{4 }$ differ only by short horizontal fragments closer to $k=0$ and $255$ in Figure 6b. However, other $T$-operators to be used in Equation (4) involve data processing of intermediate results of Equation (4), including $p$ “If…Then…”rules, which need detailed discussion of a specific model of FLC, and are outside the scope of the presented paper. Nevertheless, the fragmentary emulation of $T$-gates as parts of FLC provides the method to form an AGA version of a fuzzy controller with independent confidential control of calculations.

Two substantial remarks should be added to the proposed scheme. The first of them is that the chosen example refers to the well-known stabilization task with linear MFs. However, the AGA modeling can be applied to non-linear MFs, as any variables and profiles for linguistic values $T$ can be written in the truth table for the AGA function. Possible problems with the dynamic range here can be solved by re-calculations to the logarithmic scale and its further mapping to the scale of truth levels. Another useful tool here was partially discussed in [13,18] and refers to several correlated variables, describing a large dynamic range of values.

The second remark should be addressed to the fractional order controller scheme, shown in Section 1.3. A correct MVL function can be generated for any segment of the response curve in the multi-parametrical space of control variables. That is why AGA methods seem to overlap with the very concept of FFOPID controllers for further designs, which can be used for more complicated models than those shown above. Moreover, some commentaries should be given to the microassembler modeling of $T$-operators.

3.4. Specifics of Microassembler Modelling for $T$-Gates

Earlier proposed AGA schemes for verification and control tasks [13,16,18] were based on MIN/MAX operators, which can be easily calculated even by the trivial MCS-51 microcontroller; see Algorithms in [13,18]. But such a device is intrinsically better adapted for control tasks than for the intensive arithmetic operations used in Hamacher’s $T$-gates, which, besides arithmetic addition and subtraction procedures, suppose several multiplication and division operations. However, multiplication and division operations in an 8-bit platform mainly require the emulation of much more complicated 16-bit procedures, which can be found, e.g., in [52]. The necessary number of microcontroller work cycles for operators MIN, MAX, and Hamacher’s $T$-norm and $T^{*}$-conorm is given in

Table 5. Time costs for the calculation of logic operations MIN, MAX, Hamacher’s $T$-norm and Hamacher’s $T^{*}$-conorm by MCS-51. Software for 8-bit microassembler emulation of 16-bit operations was taken from [52].

	$\mathbf{MIN}({\mathit{x}}_1, {\mathit{x}}_2)$	$\mathbf{MAX}({\mathit{x}}_1, {\mathit{x}}_2)$	$\mathit{T}\mathit{n}\mathbf{orm}=$ ${\mathit{x}}_1{\mathit{x}}_2$$/(\mathbf{m} + (1-\mathbf{m}\left)\right({\mathit{x}}_1$$+ {\mathit{x}}_2-$ ${\mathit{x}}_1{\mathit{x}}_2\left)\right)$	${\mathit{T}}^{*}\mathbf{conorm} =$ $({\mathit{x}}_1$$+ {\mathit{x}}_2$$- (2 - \mathbf{m}){\mathit{x}}_1{\mathit{x}}_2$$)/{\mathit{x}}_1{\mathit{x}}_2$$(1 - (1 - \mathbf{m}\left){\mathit{x}}_1{\mathit{x}}_2\right)$
Total number of involved instructions	9	9	202	315
Calculation time, work cycles	10	10	251	409
Emulation of 16-bit calculations by the 8-bit platform	Not used	Not used	+	+
Addition	-	-	2	1
6 Instructions	-	-	12	6
6 Work cycles	-	-	12	6
Subtraction	-	-	2	4
7 Instructions			14	28
7 Work cycles			14	28
Multiplication	-	-	3	6
35 Instructions			105	210
50 Work cycles			150	300
Division	-	-	1	1
71 Instructions			71	71
75 Work cycles			75	75

; it increases by 30–40 times for Hamacher gates, which may substantially deteriorate the throughput of the microcontroller platform.

Certainly, platforms with FPGA can be the modern and more expensive solution for $T$-gates, but simple schemes for IoT with $T$-gates should preferably use a simpler variant, e.g., based on a dual-chip scheme [13,18].

The dual-chip platform for MCS-51 was described in detail in [13,18]; it was used for the AGA modeling of the blockchain-type distributed linked list. It is shown in Figure 8 in the simplified version without wired connections for chip control. Initially, it had a common 8-bit input data bus (shown green) and an 8-bit input address bus (shown blue), providing read/write procedures for 4 MB SRAM (Alliance Semiconductors) and 0.5 MB ROM. It provides parallel work for two MCS-51 microcontrollers, having equal access to common SRAM and ROM.

Alternative solutions may be used for small-scale agents in IoT or IoV tasks, where for the quickest and easiest emulation of 256 gradations for all parameters $m$, $x_1,$ and $x_2$ in $T$-norms and $T^{*}$-conorms, the external ROM chip with enlarged 16 MB capacity should be filled in by tabulated values of $T$-norm (or $T^{*}$-conorm), taken just from the more detailed version of Table 2. In fact, if one has 256 gradations for $x_1 , x_2$, and $m,$ it will provide high enough precision for testing.

The simplified scheme of the dual-chip circuit board [13,18], shown in Figure 8, can be applied for testing schemes with $T$-norms/$T^{*}$-conorms with some modifications.

The variant for $T$-gates will need to install a second addressing trigger register for the ROM chip and enlarge its capacity from 0.5 MB up to at least 16 MB. Moreover, that will need some modifications for the control pins used in [13,18]. A more simple variant here is to install enlarged ROM just instead of SRAM into its connector, where the chosen capacity of the ROM chip should be enough to provide the necessary precision of templates for $T$-norm and $T^{*}$-conorm. That will need to exploit all 8 output pins in registers Rg1 and Rg2, instead of the 3 ones in Rg1 in Figure 8; that is shown schematically by the dashed contour.

The given further simple example, tested on non-modified dual-chip SRAM in Figure 8, demonstrates a universal program for the reading of tabulated $T$-norm for given values of $x_1 , x_2,m$ with 256 gradations just from the ROM. ROM is necessary here, namely to exclude any illegal modifications. It is supposed that MCI held some verification procedure, as commented in previous sections, and received back from ROM the calculated value of the $T$-norm according to Table 2, written to the memory chip. Respectively, the presented further subroutine uses the addressing of Rg1 and Rg2 and control signals for appropriate pins in registers and memory chips. But for three connected pins to Rg1 in the dual-chip scheme in Figure 8, we can obtain only 8 lower gradations of m transferred by the microcontroller MCI via the input data bus highlighted in green.

$\mathbf{Algorithm} \mathbf{1}: \mathrm{Subroutine} \mathrm{TNORM} \mathrm{to} \mathrm{calculate} T( x_1 , x_2,m$). Actual values of variables $x_1 , x_2,m$ are written in microcontroller MCI.

$INPUT:$ $R0\leftarrow$m R1$\leftarrow x_1$ R2$\leftarrow x_2$

1: TNORM: MOV P2, R0; output of m

2: CLR P1.7; enable Rg1 by $\overline{CE}$

3: SETB P1.4; Rg1 writes #A23-A17

4: CLR P1.4

5: SETB P1.7; lock Rg1 to fix m

6: MOV P2,R1; output $x_1$

7: CLR P1.6; enable Rg2by$\overline{CE}$

8: SETB P1.4; write $x_1$ to Rg2

9: CLR P1.4

10: SETB P1.6; lock Rg2 to fix$x_1$

11: MOV P2,R2; output of $x_2$

12: CLR P1.3; enable SRAM by$\overline{CE}$

13: CLR P1.1;$\overline{ OE}$enables output of SRAM

14: MOV A,P0; read $x_2$ to A

15: SETB P1.1; disable output of SRAM

16: RETI

OUTPUT: A→$T(m$,$x_1, x_2$) for further calculations

4. Discussion

The proposed simplified scheme for direct parametrical control of agents’ subsystems and verification creates the possibility of avoiding the application of expensive AES and one-time pad secret coding software [45] in simple agents and IoT devices in cases of non-intensive transfer of verification and correction data. It gives the possibility to quickly block the operation of actuators in dangerous situations or to check the operability of subsystems and sensors in reduced load mode. One more application is the distant learning mode, or restoration of damaged data after failures and faults. Sequential instructions for activation of the lowered by $m$-parameter level of signals can check sensors and actuators. Such a mode may be used for data restoration with the help of the distributed blockchain ledger, written as backup copies in loyal external network nodes [13,18]. The proposed AGA emulation of parametrical $T$-gates is the way to compare distant admin’s instructions with internal data and external ledger versions.

The more detailed further design of closed loop control schemes with parametrical gates refers to several problems for intellectual agents.

The first of them is the choice of a minimal set of algorithms to quickly regulate all basic subsystems of the agent, adapting robotic agents to urgent threats or excluding negative consequences in the event of crashes. Here, one should also mention the possibility of deleting confidential commercial data in the event of physical or network attacks. However, the integration of new tools should not require substantial modifications to earlier-designed algorithms and data lines. As it was discussed in [13], a potential robotic agent can include such exhausted optoelectronic components as frequency, phase, and polarization coding, wavelength multiplexing systems, continuous-variable QKD schemes, and wired fiber optics schemes with dispersion compensation fiber, chirped Bragg gratings, dispersion-shifted fiber, and reduction of the chromatic dispersion effect by optimal initial pulse duration. Potentially, such schemes can be further considered as potential components for AI network control of agents, but the MVL and fuzzy logic schemes for control and data verification should already be prepared for such tasks. Thus, new effective logic components are to be designed and applied.

The second actual problem is to adapt various logic modules and software platforms to trust estimates, which are necessary for intellectual agents working out of expensive trusted networks [13,45]. This task is especially important for the heterogeneous logic architecture of the agent [13], which combines fuzzy systems, traditional controllers, and MVL control circuits.

The third task is to design the platform for efficient distant self-checking or verification of the autonomous agent, involving data and algorithm integrity in the event of faults. Such methods can use blockchain schemes and externally distributed backup data storages [13,18], created in loyal external network nodes (or bots).

The fourth task is to apply more widely QKD lines [45,48,49] and quantum random number generators [17] in schemes with an episodic generation of quasi-random keys for the agent, providing secured data storage in the agent and reliable protection from illegal physical impacts on the distant agent.

One more aspect is the conjugation of certificated quantum modules with experimental schemes in verification procedures [13,18]. In spite of their current image as nice products [45], quantum optics can obtain more wide applications, and autonomous agents should use both quantum and classical wireless data lines. However, all additional functions should be optimally combined with the basic work functions of robotic agents and require new solutions for the agent’s design, including an extended set of logic functions and procedures.

Another unsolved problem here is that prospective quantum computing is not yet adapted to traditional PID and fuzzy controllers, as it demands reversible logic gates [45,48,49]. Namely, the sequential enlargement of model complexity is the way to test new models for technical systems controlled by PID or fuzzy-PID controllers [31,32,34]. AGA emulation of homeostatic and fuzzy controller models can complement self-learning procedures and the method to describe the neural network by the MVL function, proposed in [16]. At the same time, the application of quantum computers [1,2] supposes the application of sets of qubits, detected by different sensors for single photons, thus providing the distribution of calculated parameters. Such data prompt the idea to combine quantum computers with approximate fuzzy calculations, but the realization of such a scheme is now limited by the necessity to design special reversible analogs of fuzzy logic gates and schemes, which is a topic for future research. However, some auxiliary classic schemes for the integration of quantum and classic data lines can already be tested using the separate control channels in $T$-norms and $T^{*}$-conorms [12,26].

One should especially note that the design of quantum switchers for qubits is also a task for the future, but at least the complicated enough position-based verification protocol [13,16] based on entangled photon pairs can be already described and controlled by AGA procedures, using the time schedule for classical measurements. However, as mass IoT and IoV schemes scarcely can be the application field for expensive quantum technologies, the next necessary step is to adapt verification procedures with stored sets of quantum keys just to mass 8-bit platforms.

Principally, the direct method to generate a switching function [38] for confidential controller re-switching and data verification is to choose input and output variables, compose the MVL truth table, write product terms according to the known rules, and further, if necessary, minimize (i.e., simplify) the obtained expression for more fast computing. However, the attractive property of AGA modeling is the ability to use expert knowledge and to design a guaranteed correct AGA model function “by hand”, which is comfortable for further analysis and corrections. This option overlaps with the method to define fuzzy membership functions [23,24,26,46] as triangular templates, which can be adjusted afterwards. But the advantage of the MVL model is the possibility to use arbitrarily given non-monotonous shapes of the switching function profile, which can be asymmetrical, and it does not have such limitations as the normalization to 1. One can improve the model sequentially by adding new input variables and enlarging the number of gradations of these variables. In other words, MVL is expected to simplify the realization of such schemes.

5. Conclusions

The method is proposed to combine classical control signals with quantum keys obtained from the QKD line by means of $T$-norms and $T^{*}$-conorms, which are well known in fuzzy logic. These triangular logic gates are a tool to provide fast, confidential control over distant agents. A simple enough scheme of confidential transfer of instructions to a distant agent gives the possibility of avoiding expensive full-scale secret coding by means of AES and one-time cipher pad methods for the internal critical contours of robotic agents.

Such a method uses the non-secret transfer of a sequence of numbers by any classic data line, disclosing necessary bits positions in the next secret random key, attributed to the time parameter or to the number of the key in the list. The necessary store of keys here can be written in the agent beforehand by means of the QKD line, generating episodically secret keys in the robot admin–robot agent pair.

The algorithm for confidential verification with the help of the comparison of data, coded by a $T$-gate, is intended for procedures that are activated in case of faults and errors. If a short instruction can be given by a sequence of 8–16-bit numbers, then it can be easily used for fast confidential re-switching of schemes, fuzzy controllers and their MVL emulations, or for data corrections in MVL linked lists. MVL linked lists are considered here as non-secret data storage, but their illegal modifications should be excluded.

The method is described to use multiple-valued logic of AGA for modeling a simple fuzzy logic stabilizing controller using $T$-gates; values of typical linguistic variables can be easily described by simplified procedures just without the direct use of truth tables.

Recommendations are given for the earlier proposed 8-bit dual-chip circuit board, which can reproduce $T$-norms and $T^{*}$-conorms.

We hope that the proposed simple methods will be a useful step for verification in an agent’s multi-party data processing without disclosing data.