A System of Superimposed Chaos
Copyright © 2005, David A. Epstein.
All Rights Reserved.

June 19, 2005

Introduction: Chaos Theory

When I was attending CSUH, Chaos Theory was an exciting area of mathematics and physics to study. We took classes in Dynamical Systems & Chaos, devoted some independent study to the subject, admired beautiful geometric fractal drawings, and learned about everything from the Duffing Equation to Julia Sets. Those were great days; our minds expanded in so many new directions.

One of those directions was exploring the consequences of a new idea. I learned that the primary idea derived from Chaos Theory is sensitivity to initial conditions. This is best illustrated by the famed example of the Butterfly Effect. The Effect states, colloquially, that a butterfly fluttering her wings can change the weather half-way around the world. Small changes in the inputs to a system can have dramatic effects upon its behavior.

Chaos occurs when a nonlinear dynamical system has parameter values (dampening and driver constants) that lead to unpredictable movement between periodic cycles. Each of these cycles has at least one stable point. As a result, the system should normally exhibit periodic stability; hence, the chaotic behavior is apparent disorder (re: noise) between  cyclical patterns of order. This process infinitely repeats itself recursively, resulting in nested orderly patterns within larger similar patterns, leading to the central property of self-similarity.

The chaotic behavior is occuring because of the driver force. A dynamical system described by a nonlinear differential equation is created by an iterative process dependent upon these dampening and driver constants. For each iteration, even with a steady, periodic driver force, the driver proliferates slight changes in the system's behavior. These errors are magnified with each successive iteration; but the magnification is occurring because computers can't calculate accurately enough. If we had powerful enough computers that computed with greater exactness using more significant digits, there wouldn't be any chaos.

Yet is it possible to take a collection of these chaotic systems to create a larger system, without the aid of more powerful computers, that would be chaos-free? In a classical deterministic system, the answer is No. So long as the system is subjected to a regular driver force, and sensitive to specific initial dampening and driver constants, it will create these anomolies resulting in chaotic behavior. However, it might be possible to generate a network of superimposed chaotic systems, whose aggregation will result in a perfectly stable system that doesn't create these chaos-inducing errors. This is what I wish to explore. (*****)

More Powerful Computability through Superimposed dynamical systems

Here is an outline of the basic idea:

1.  Use the dampening and driver constants as fixed points. Instead of altering these constants to discover another chaotic system, keep these constants fixed and modify the dynamical equation to morph into another chaotic system. The equation can't be altered by a trivial constant that will simply shift the behavior along one of the axes; it must be modified by using at least one of the variables.

2.  Through a self-similar process, find a finite family of dynamical equations, each exhibiting chaos through these fixed points. The superposition of all these equations results in a Super Stable System (SSS) that, in effect, drives the process of iterative regeneration. From this perspective, each of these family equations is a single point, or periodic cycles, in the larger Super system.

3.  The superposition will occur in ONE of these ways:

a.  All family equations are run concurrently. The result is the simultaneous rendering of multiple butterflies to create a stable cycle of chaotic meanderings. This family is an abelian set, meaning that the order of morphings is irrelevant. Any ordering should lead to the same result: the creation of the super set, the SSS. Unlike in a singular chaotic system, there should be no errors, for each rendered system will in effect transfer its errors onto the subsequent system, which will further transfer them to yet the next one, and so forth. Since the systems are created simultaneously, the net result is a closed system with zero errors (the "errors" have nowhere to go!). This is similar to Feynman's idea of explaining away the Heisenberg Uncertainty Principle with his infamous Feynman Diagrams that depicted histories of particle collisions. Each successive diagram absorbs the uncertainty inherent in the previous one. The displacement of certainty in a previous diagram is recouped by the current one! Likewise, with SSS, the net result is zero uncertainty.

b. Family equations are run serially. The first equation creates a chaotic sytem which is graphically plotted. Then, through some control mechanism, it morphs into the second system which is plotted, and so forth. Since each successive system will absorb the errors of the previous one, and will magnify them through computational inaccuracies via the driver forces, the control mechanism must compensate for this magnification. Hence, this control mechanism must be a superimposed driver force that regulates the data flow and acts as a self-correcting agent. I would argue that it would need to operate through the principles of fuzzy logic within the confines of these computational numerical methods to achieve these results, for any predefined, deterministic force would result in the same error prone propagation. The set of this family of equations must by it's very nature be non-abelian. Different ordering of rendered systems will lead to different results. Thus, this would be a far more difficult pathway than option "a" to create a unified SSS.

c. Each family equation is created through an iterative process. They will be related through homeomorphisms (these are mappings that are one to one, onto, have continuous and invertible functions). This could be run either concurrently or serially, respectively abiding by a or b.

4.  The superimposed system will be a SSS, as noted above. It will have periodic cycles of chaotic behavior which will be stable at all times, cyclical behavior about the fixed parameter points! From the perspective of the Super system, the chaotic behavior of the individual dynamical systems will be the result of "symmetry breaking" of the Super system. In effect, each dynamical system will be the emergence of some "defective" process, this symmetry breaking.

5.  Because there will be no errors in the creation of this SSS, we will in effect increase computing power. See what I said about this in the last paragraph of the Introduction.

------------------------------------------------------------------------------------------------------------------

(*****) Mathematically, this will be difficult to demonstrate. The idea is to start with a known differential equation that exhibits chaos under certain conditions. A substitution of one of the following forms is made:

A) substitute g(x) for x and refactor.
B) add h(x) to both sides of the equation and refactor.
C) apply some transformation to the equation, solve the equation and then apply an inverse transform. See Fourier Transforms for example.

The refactored equation must either be conjugate to the original equation or map to another chaos-inducing equation.

We start with a differential equation that exhibits chaos under certain conditions (i.e. specific dampening constant k and driver constant D):

The general equation is of the form: f "(x) + k*f '(x) + p(x) = D*h(t), where p(x) is a non-linear term.

A) By substituting g(x) for x, we get the following:
*)  f "(g(x)) + k*f '(g(x)) + p(g(x)) = D*h(t).
*) We have to use the chain rule for each of the first 2 terms:
     f "(g(x)) = {f(g(x)'}' = [f '(g(x))*g'(x)]' = f "(g(x))*(g'(x)^2) + f '(g(x))*g''(x).
     f '(g(x)) = f '(g(x))*g'(x)
*) So by substitution the general equation becomes:
    {g'(x)^2}*f "(g(x)) + {g''(x) + k*g'(x)}*f '(g(x)) + p(g(x)) = D*h(t).

The challenge is to either refactor this into another equation that exhibits chaos when using the same dampening & driver constants, OR refactor into another form of the general Equation: z"(x) + kz'(x) + q(x) = D*h(t). To get it into this latter form, we need to substitute:
i)  z"(x) = {g'(x)^2}*f "(g(x))
ii)  z'(x) = {g"(x)/k + g'(x)}*f '(g(x))
iii) q(x) = p(g(x))

B) By adding h(x) to both sides of the general equation, we get:
*) f "(x) + k*f '(x) + p(x) + h(x) = D*h(t) + h(x).
*) This becomes: f "(x) + kf '(x) + r(x) = Dcos(wt) + h(x)
*) Which becomes: f "(x) + kf '(x) + p(x) = q(x),
(where r(x) = p(x) + h(x), and q(x) = Dcos(wt) + h(x))

The challenge here is finding the correct h(x) such that the last equation exhibits chaos.

C) More on this later.


Let us take a specific equation to illustrate the complexity of the above task. The Duffing Equation induces chaos under certain conditions (e.g. dampening constant = .08, driver constant = .2). This equation is of the form:
    f "(x) + k*f '(x) + f(x)^3 = D*cos(wt).

A) By using the same technique as the general equation, substituting g(x) for x, we get the following:
*) f "(g(x)) + k*f '(g(x)) + f(g(x))^3 = D*cos(wt).
*) We have to use the chain rule for each of the first 2 terms:
     f "(g(x)) = {f(g(x)'}' = [f '(g(x))*g'(x)]' = f "(g(x))*(g'(x)^2) + f '(g(x))*g''(x).
     f '(g(x)) = f '(g(x))*g'(x)
*) So the substituted Duffing equation becomes:
     {g'(x)^2}*f "(g(x)) + {g''(x) + k*g'(x)}*f '(g(x)) + f(g(x))^3 = D*cos(wt).

Again, if we want to get it into the form z"(x) + k*z'(x) + q(x)^3 = D*cos(wt), we need to substitute:
i)  z"(x) = {g'(x)^2}*f "(g(x))
ii)  z'(x) = {g"(x)/k + g'(x)}*f '(g(x))
iii) q(x) = f(g(x))