## Abstract

We discuss how threshold mechanisms can be effectively employed to control chaotic systems onto stable fixed points and limit cycles of widely varying periodicities. Then, we outline the theory and experimental realization of fundamental logic-gates from a chaotic system, using thresholding to effect control. A key feature of this implementation is that a single chaotic ‘processor’ can be flexibly configured (and re-configured) to emulate different fixed or dynamic logic gates through the simple manipulation of a threshold level.

## 1. Outline

We will first discuss the general formalism of an easily implementable control strategy, namely, the use of a simple *threshold* mechanism to limit the dynamic range of a state variable, thereby effecting flexible control over the dynamic behaviour of the system. Then, we will focus on the application of thresholding to *flexibly* obtain a wide range of controlled logic-gate responses, from a *single* chaotic element. The ‘dynamic logic cells’ thus obtained can potentially serve as building blocks for a novel dynamic logic architecture.

## 2. Threshold control algorithm

Consider a general *N*-dimensional dynamical system, described by the evolution equation, d*x*/d*t*=*F*(** x**,

*t*), where are the state variables. In this system, a variable

*x*

_{i}is chosen to be monitored and threshold controlled. The prescription for threshold control is as follows: control will be triggered whenever the value of the monitored variable exceeds a prescribed critical threshold

*x*

^{*}(i.e. when

*x*

_{i}>

*x*

^{*}) and the variable

*x*

_{i}will then be reset to

*x*

^{*}(Sinha 1994, 1995, 2002; Glass & Zheng 1994). The dynamics continues until the next occurrence of

*x*

_{i}exceeding the threshold, when control resets its value to

*x*

^{*}again.

This method only involves the monitoring and the occasional resetting of a single variable and no parameters are perturbed in the original system. The theoretical basis of the method does not involve stabilizing unstable periodic orbits (Ditto *et al*. 1990; Ott *et al*. 1990), but rather involves *clipping* desired time sequences and enforcing a periodicity on the sequence through the thresholding action, which acts as a resetting of initial conditions. The effect of this scheme is to *limit the dynamic range* slightly, i.e. ‘snip’ off small portions of the available phase space and this small controlling action is effective in yielding regular dynamics. In fact, chaos is advantageous here, as it possesses a rich range of temporal patterns, which can be clipped to widely ranging stable behaviours. This immense variety is not available from thresholding regular systems.

It has been analytically proven that thresholding can yield stable periodic orbits of all orders in one-dimensional chaotic maps (Sinha 1994, 1995, 2002; see table 1). The analytical results based on symbolic dynamics (Sinha 1994, 1995, 2002; Glass & Zheng 1994) are exactly corroborated in a circuit realization of the logistic map (Murali & Sinha 2003; see figure 1 for traces of representative controlled orbits).

The success of the threshold method on higher dimensional systems, including hyperchaotic systems, has also been demonstrated through extensive numerical and laboratory experiments (Sinha & Ditto 2001; Murali & Sinha 2003). For instance, it has been implemented in circuit realizations of chaotic jerk systems, which are nonlinear third-order ordinary differential equations (ODEs),(2.1)where *G*(*x*) is a piecewise linear function: *G*(*x*)=*B*|*x*|−*C* with *B*=1.0, *C*=2.0 and *A*=0.6 (Sprott 2000). On this system, we implement the threshold mechanism on variable *x*, i.e. when *x*>*x*^{*}, *x* is clipped to *x*^{*}. A precision-clipping circuit (Maddock & Calcutt 1997) is employed for this threshold action.

Another representative example is the double-scroll chaotic Chua's attractor given by the following set of (rescaled) three coupled ODEs (Dmitriev *et al.* 2001)(2.2)(2.3)(2.4)where *α*=10 and *β*=14.87, and the piecewise linear function with *a*=−1.27 and *b*=−0.68. In this system, we implement an even more minimal thresholding. Instead of demanding that the *x*_{1} variable be reset to *x*^{*}, if it exceeds *x*^{*}, we demand this *only* in equation (2.3). This has an easy implementation, as it avoids modifying the value of *x*_{1} in the nonlinear element, which is hard to do. Thus, all we do then is to implement instead of equation (2.3), when *x*_{1}>*x*^{*}, and there is no controlling action if *x*_{1}>*x*^{*}.

The results of the threshold mechanism in these systems are summarized in table 2. It is clear that the chaotic dynamics gets clipped to different stable regular cycles for different threshold values.

The control transience is very short here (typically of the order of 10^{−3} times the controlled cycle). This makes the control practically instantaneous. The underlying reason for this is that the system does not have to be close to any particular unstable fixed point before control comes into effect, as in schemes based on the Ott–Grebogi–Yorke concept (Ditto *et al*. 1990; Ott *et al*. 1990). Once a specified state variable exceeds the threshold, it is caught immediately in a stable orbit. Hence, there is no significant interval between the onset of control action and the achievement of control. In addition, thresholding does not entail any run-time computation during control, which reduces control latencies. Lastly, threshold control is highly robust with respect to noise, both in the threshold setting and in the dynamics. This is easy to see analytically for one-dimensional systems, since thresholding by design creates a *super-stable* orbit (as the derivative of the effective map which determines the stability of the controlled system is exactly zero (Sinha 1994, 1995, 2002)). This robustness is also borne out in numerical and experimental realizations for higher dimensional systems.

### (a) Hyperchaotic system

The method has also been demonstrated on a hyperchaotic electrical circuit (Murali & Sinha 2003). This constitutes a stringent test of the control method since the system possesses more than one positive Lyapunov exponent, hence *more than one unstable eigen direction* has to be reigned in by thresholding a *single* variable. In particular, we consider the realization of four coupled nonlinear (rescaled) ODEs of the form(2.5)(2.6)(2.7)(2.8)where , with *k*=3.85, *b*=88 and *β*=18 (Murali *et al*. 2001). Again, we implement a *partial* thresholding on variable *x*_{3}; whenever *x*_{3}>*x*^{*} in the system, *G*(*x*_{1}−*x*_{3}) in equation (2.5) becomes *G*(*x*_{1}−*x*^{*}), i.e. we have , while equations (2.6)–(2.8) are unchanged. When *x*_{3}≤*x*^{*}, there is no action at all (see figure 2).

Both our experiments and numerical simulations (which are in complete agreement) show that this scheme successfully yields regular *stable* cycles under a wide range of thresholds (Murali & Sinha 2003). A representative example with threshold set at 0*V* is shown in figure 3, which shows the controlled cycle in the *V*_{1}−*V*_{2} plane corresponding to the rescaled *x*_{1}−*x*_{3} plane of equations (5)–(8).

Thresholding, then, is especially useful in the situation where one wishes to *design* controllable components that can switch flexibly between different behaviours. Calibrating the system characteristics at the outset, with respect to threshold, gives one a *look-up table* to directly and simply effect control at all consequent times, at no run-time cost. Thus, this scheme has considerable potential for use in chaos-based applications. Further, the simplicity of the controller implies low complexity costs, which is important in technical applications seeking to exploit the richness of chaos in a direct and an efficient way. In the section below, we shall delineate one exciting application of thresholding, namely obtaining different logic responses from a chaotic element.

## 3. Computing with chaotic elements

Here, we will demonstrate how the threshold controller, which clips chaos into different temporal patterns, can serve as a basis for a dynamic logic unit (Sinha & Ditto 1998, 1999). The aim is to use a single chaotic element to emulate different logic gates, with the ability to switch easily between the different operational roles. Such a computing unit may then allow a more dynamic computer architecture, which is more flexible than fixed hardware. Unlike existing paradigms that try to achieve flexibility by flexible wiring, we envisage here the flexibility arising from the computational modules themselves. Such flexible logic modules can serve as the basis for a programmable general-purpose computer, as all the fundamental gates, which are the necessary and sufficient components of a universal computing machine, can be realized by them.

The necessary and sufficient components of computer architecture to date are the logical AND, OR, NOT and Exclusive OR (XOR) operations from which we can directly obtain all basic operations, like bit-by-bit addition and memory (Mano 1993; Bartee 1991). In conventional computer architectures, all gates can be constructed by combining the fundamental NOR (or NAND) operation. For example, AND can be realized by: AND(X,Y)=NOR(NOR(X,Y),NOR(X,Y)) and XOR(X,Y) = NOR(NOR(NOR(X,NOR(X,Y))),NOR(NOR(NOR(X,X),Y))).

Clearly, this conversion process is inefficient in comparison with direct implementation (which would require only one unit and no cascaded operations). This is especially significant considering, perhaps, that such fundamental operations may be performed billions of times. Therefore, the direct and flexible implementations of gates are useful and could prove highly cost effective.

Here, we will show the *direct and flexible implementation* of *all* these logical operations by thresholding a single chaotic element.

Consider a single chaotic element, whose state is represented by a value *x*, as our *chaotic chip* or *chaotic processor*. This element receives two inputs *I*_{1} and *I*_{2} (for AND, OR and XOR), or one input *I* (in case of NOT) and outputs a signal *O*. The logical operations are defined by patterns of input-to-output mapping represented by the truth table in table 3. Our aim is to design a scheme such that the chaotic elements will yield the appropriate output for all possible sets of inputs.

In our scheme, all logic gate operations involve the following steps (figure 4):

Inputs:

for the AND, OR and XOR operations, and

*x*→*x*_{0}+*X* for the NOT operation

where *x*_{0} is the initial state of the system, and *X*=0 when *I*=0 and *X*=*δ* when *I*=1.

Chaotic update:

*x*→*f*(*x*)

where *f*(*x*) is a chaotic function.

Threshold mechanism to obtain

*output*, i.e. the output*Z*is:

*Z*=0 if *f*(*x*)≤*x*^{*}, and

*Z*=*f*(*x*)−*x*^{*} if *f*(*x*)>*x*^{*}

where *x*^{*} is the threshold.

This is interpreted as *O*=0 if *Z*=0 and *O*=1 if *Z*=*δ*.

In our implementation, we demand that the *input and output have equivalent definitions* (i.e. 1 unit is the same quantity for input and output). This is also demanded among the different logical operations. Therefore, constant *δ* assumes the same value throughout a network, and this will allow the output of one gate element to easily couple to another gate element as input. The elements can then be ‘wired’ directly into gate arrays, implementing compound logic operations.

In order to obtain the desired input–output response, we need to satisfy the conditions enumerated in table 4 for the different gates. Note that the symmetry of inputs reduces the four conditions in the truth table 3 to three distinct conditions, with rows 2 and 3 of table 3 leading to condition 2 in table 4. Hence, given a dynamics *f*(*x*), corresponding to the physical device in actual implementation, one must find values of *x*^{*} and *x*_{0} that satisfy all the conditions in table 4 simultaneously, in a robust manner (Munakata *et al*. 2002).

Now, we give an explicit example of the basic procedure laid out earlier. As a representative chaotic function, we take *f*(*x*) to be the prototypical logistic map, a map known to be of widespread relevance to physical and biological chaotic phenomena *f* (*x*)=4*x* (1−*x*), where *x*∈[0,1]. We select the constant *δ* to be 1/4. This value is common to both input and output, and to all logic gates. Table 5 shows a set of *x*_{0} and *x*^{*} values that simultaneously satisfy all the conditions in table 4.

For instance, for the AND operation, *x*_{0}=0 and *x*^{*}=3/4. This satisfies the three conditions in table 4 as follows:

We would also like to underscore that the different chaos control and synchronization schemes in existence, could possibly be exploited similarly, to obtain different dynamic computing schemes.

The use of chaotic elements is compared with the possible use of periodic elements on one hand, and random elements on the other. It is not possible to extract *all* the different logic responses from the *same* element in case of periodic components, as the temporal patterns are inherently very limited. Therefore, periodic elements do not offer flexibility. Random elements, on the other end, have many different temporal sequences; but they are *not deterministic* and hence one cannot use them to *design* components. Only chaotic dynamics enjoys both richness of temporal behaviour and determinism. Here, we have shown how one can select temporal responses corresponding to different logic-gate patterns from such dynamics, and this ability allows us to construct flexible hardware (our efforts are in contrast to the earlier efforts of Toth (1995)1).

The above theoretical scheme of implementing logic gates has been completely verified in proof-of-principle experiments on logistic map circuits. We have also extended the scheme to realize combination logic circuits, such as half-adders. Therefore, the robust cascading of these dynamic logic units allows the construction of basic computation modules, which are important steps towards implementing bit-by-bit arithmetic operations and computer memory.

One can also use continuous time-chaotic systems, for instance, the Chua's circuit given by equations (2.2)–(2.4), to implement logic gates via the simple thresholding discussed in the section above (Murali *et al*. 2003*a*,*b*). A representative example is the implementation of the fundamental NOR operation on a pair of inputs (*I*_{1}, *I*_{2}). This simply involves setting an input-dependent threshold *x*^{*}+*X*_{1}+*X*_{2}, where *X*=0 when *I*=0 and *X*=*δ* when *I*=1 (see figure 5 for a schematic). That is, the threshold level is: *x*^{☆} if the input set is (0, 0), *x*^{*}+δ if the input set is (0, 1)/(1, 0) and *x*^{*}+2*δ* if the input set is (1, 1). The output is interpreted as 0 if the thresholded variable *x*_{i} is below threshold. The output is interpreted as 1 if the thresholded variable *x*_{i} is above threshold, and *x*_{i}−*x*^{*}=*δ*.

Now, for the NOR gate, we must have an output 1 for input set (0, 0), and output 0 for input sets (0, 1), (1, 0) and (1, 1). This is obtained robustly for *x*^{☆}∼0 and *δ*∼1.84, as evident from figure 6.

Therefore, unlike conventional *static* architecture-based computing paradigms, these dynamical computing elements have flexibility and re-configurable capability (Sinha *et al*. 2002*a*,*b*). Thus, it can yield a gate architecture that can dynamically switch between different gates, without rewiring the circuit. Such configuration changes can be implemented either by a predetermined schedule or by the outcome of computation. Therefore, the flexibility of obtaining different logic operations using varying thresholds on the same physical element may lead to new dynamic architecture concepts (Taubes 1997).

Further, since all logic gates are obtained from identical single chaotic circuits, one can envision that this will enable more efficient packing, in analogue programmable gate implementations, as well as more efficient design. Another significant potential advantage is also related to making all elements identical. With clever programming approaches that take advantage of identical elements, elements that endure damage or errors can be effectively disconnected from the whole bath of chaotic elements and the remaining elements can continue normal operations.

In conclusion, we have demonstrated the basic principles of a universal programmable chaotic logic unit that can potentially provide the starting point for more mature approaches of flexibly dynamic computational platforms, based on the principle of large numbers of identical, re-configurable and re-programmable units.

## Acknowledgements

This work was supported under a grant from the US Office of Naval Research (N00014-02-1019).

## Footnotes

One Contribution of 15 to a Theme Issue ‘Exploiting chaotic properties of dynamical systems for their control’.

↵Our efforts are in contrast to the earlier efforts of Toth, A. & Showalter, K. 1995

*J. Chem. Phys*.**103**, 2058, who obtain gates from chemical systems by delicately tuning many parameters (involving both the construction of the apparatus, as well as the geometric configuration and timing of the input and output waves). Fine adjustments of these lead to the desired phenomena. In contrast here we have an adjustable threshold defining all the gates from the same system.

- © 2006 The Royal Society