*Or, how to mix fourth-year engineering classes, Aristotlean elemental theories of personalities, and linear differential equations to explain why some relationships do what they do.*

### Basic Vibration Theory

Consider a basic "spring-mass-damper" system -- the fundamental unit of vibration and system control theory. It's a mass, attached to the world by a spring and a shock absorber (aka "damper"). See figure 1. Note that, in real life, the system may not look anything like figure 1, but still act like it.

________ | | |--/\/\spring/\/\--| | mass | | |________|--[[[-damper-]]]--| O O | |---> x Figure 1

You can push on the mass, and it moves. Without a shock absorber, if you push it, it will oscillate back and forth. A heavy mass and light spring will oscillate slowly but over a long distance -- think the Foucault pendulum in the Smithsonian (gravity, in that case, takes the place of the spring). A light mass and a heavy spring will oscillate quickly over small distances -- think a guitar string that's been plucked. If there's a strong shock absorber, it won't oscillate at all, but will slowly move to the zero point -- think the Foucault pendulum if you filled the lobby with pancake syrup.

Mathematically speaking, the equation for the motion is:

x = exp[(a+bi)t]

where

`x`is the position of the mass,

`t`is the time,

`(a - bi)`is a complex number determined by the mass, spring, and damper, and

`exp`is the exponential function -- note that

`exp(at)`is an exponential growth or decay,

`exp[(bi)t]`(where

`i`is

`sqrt(-1)`) is a sinusoid, and

`exp[(a+bi)t]`is the exponential growth or decay multiplied by the sinusoid.

We can define relative damper and spring strengths as

D = [damper strength] / [mass] S = [spring strength] / [mass]

and, then, solving the relevant differential equations results in a pair of solutions for

`a`and

`b`. Specifically,

a = - 1/2 D b = sqrt[ S - 1/4 D^2 ]

in the case where

`D < 2 sqrt(S)`, and

a = - 1/2 D - sqrt[ 1/4 D^2 - S ] b = 0

in the case where

`D > 2 sqrt(S)`. The first solution corresponds to cases where the system oscillates (termed "underdamped"), and the second solution corresponds to cases where the system does not oscillate (termed "overdamped"). The case where

`D = 2 sqrt(S)`is termed "critically damped", and corresponds to amount of damping that will give the quickest possible return to zero without oscillations for a given spring and mass.

The pedants will note that, properly, the exponential of a complex number is also a complex number, and it doesn't make sense to speak of position equalling a complex number. For the pedants, we have a special version of the formula, which is:

x = 1/2 ( exp[(a+bi)t] + exp[(a-bi)t] )

This amounts to simply using the first formula and ignoring the imaginary part, but it makes the pedants happy. So we will use the first version, and consider it to be a shorthand for the second.

### System Control Theory

Now, there is an interesting question -- suppose we attach a device to this mass-spring-damper system, that measures where the mass is, and pushes on it with a force

`F(x)`determined from that position. Specifically, the picture now looks like figure 2.

________ | | |--/\/\spring/\/\--| F(x) --> | mass | | |________|--[[[-damper-]]]--| O O | |---> x Figure 2

The equation that determines

`F(x)`from

`x`is the "controller". One of the most common forms is a "PID" controller, short for "proportional-integral-differential" controller. In this controller, the equation takes the form of

F(x) = Cp (z-x) + Ci Int(z-x) + Cd d(z-x)/dt

where

`z`is a "desired" mass position,

`Int(x-z)`is a time integral,

`d(x-z)/dt`is a time derivative, and

`Cp`,

`Ci`and

`Cd`are coefficients that can be adjusted based on how we want the system to behave.

Given a controller of this type, the mass will move to the position determined by z, and it will do it in a manner described by the same

`exp[(a+bi)t]`solution, but this time with different coefficients that are determined by a combination of the system coefficients and the controller coefficients.

To analyze how this works, consider a system that has just a mass -- no spring or damper. If we set

`Ci`and

`Cd`to zero, the controller acts exactly like a spring. The mass won't get to

`z`and stop -- it will be moving when it gets there, and move past it by momentum, and oscillate back and forth indefinitely. Now, if we set

`Cd`to some nonzero number, it acts like a damper, causing the controller to apply force in a way that slows the mass down when it is moving quickly, and it stops oscillating.

The purpose of

`Ci`is slightly more complicated. Suppose that something else pushes on the mass, with a force of

`G`, as in figure 3.

________ | F(x) --> | |--/\/\spring/\/\--| | mass | | G ----> |________|--[[[-damper-]]]--| O O | |---> x Figure 3

Without

`Ci`, the system will settle down to a stable position where the forces balance, according to the equation

Cp (z-x) = G

which can be solved for

`x`to get

x = z - G/Cp

which is not the position we want the mass to end up. A non-zero

`Ci`allows the system to have a "memory" of past positions, and those result in the ability to have a force to counteract

`G`even when the system is sitting stationary at

`x=z`. And thus, even with an applied force, the system will go where we tell it.

Of course, it's possible to choose values of

`Cp`and

`Cd`that cause the system to do things that a real mass-spring-damper system would never do. For instance, we can make

`Cd`negative. On a system with a lot of real damping, that would be a good thing; it would counteract the damping, and allow the system to respond faster to changes in desired position. On the other hand, on a system with less real damping, we can get a situation where the exponential grows instead of decays -- this is called an "unstable" system. Unstable systems can have two different types. In one type, the system oscillates around the desired position, but the oscillations grow instead of go away. In the other type, the system simply runs away from the desired position, at an ever-increasing rate.

### Application as a Description of People

We can consider the system of figure 3 to be an approximate model of a person's emotional state. The position

`x`is the emotional state, and external things kick it around by changing (

`z`). Depending on the person's internal masses, springs, dampers, and controllers, their emotional state will have different sorts of reactions to being kicked.

For instance, consider a couple of people, Person A and Person B.

Person A has a controller with high

`Cp`and low

`Ci`. Her reaction to being kicked will be to move a lot immediately when something kicks her, but as soon as she's no longer being kicked, she moves right back where she was. This is describable as being a "Fire" sign; she processes things immediately, and inputs have dramatic effects but the effects only last for as long as they exist.

On the other hand, Person B has a controller with low

`Cp`and high

`Ci`. His reaction to being kicked is to move a much smaller amount, but the integral component of the controller stores the kick for a long time, and so he moves back very slowly. In fact, it's even possible for him to keep moving away for a short time after the kick stops. This is describable as being an "Earth" sign; he processes things slowly, and inputs have smaller but long-lasting effects.

It is left as an exercise to the reader to find the properties that correspond to "Water" and "Air" signs.

### Relationships

Both Person A and Person B are stable, when considered as a system unto themselves. Given any input within a finite range, their emotional state will also be within a finite range, and will not grow out of proportion to the input.

However, interesting things happen if we start putting people in a relationship. In this model, a relationship is a connection where some portion of one person's

`x`is added to the other person's

`z`, and vice versa. Each person's emotional state influences the other, forming a large loop.

First, let's consider if Person A has a relationship with someone much like herself. When something hits her, she spikes up (say 1 unit), which makes her partner spike up (say 1/2 unit) which makes her spike up some more (say 1/4 unit) and so forth, in an infinite series that sums to a finite sum -- in this case, somewhat less than 1.5 units. A bigger spike, but not a lot bigger. And then, when the something is no longer hitting her, she drops back down, her partner drops back down, and things go back to zero almost as fast as they did with her alone.

This, one suspects, is a comfortable sort of relationship for Person A. Within the context of the relationship, emotions behave much as she's used to, and have the same sort of stability properties that she herself has.

Now, let's consider if Person B has a relationship with someone much like himself. Much as with Person A and her partner, the result is not significantly different from what happens with either one of them alone -- an emotional kick produces the start of a bump, which starts a much smaller emotional bump for his partner a bit later, which produces a nearly-negligible secondary bump for Person B that starts still later, and so again the result within the relationship is much like what Person B does by himself.

Again, one suspects this is a comfortable sort of relationship for Person B; in it, emotional feedback acts much as he's used to within himself.

Finally, let's consider a relationship between Person A and Person B. This time, when Person A gets kicked, this produces a spike. The spike starts a bump for Person B. Now, this bump produces a longer-lasting input to Person A, and so her response is not a spike but a continuous high result. That continuous high result causes Person B's bump to start growing higher, which makes Person A's spike higher, which makes Person B's bump grow faster. And, presto, exponential growth; the system is unstable.

This is, for rather clear reasons, not a comfortable situation for either Person A or Person B. Even the tiniest emotional inputs will create results that slowly build on each other. In cases where Person A would instinctively expect a quick spike response, she gets a long-lasting bump. In cases where Person B would instinctively expect a low bump, he gets a high spike. For both people, these reactions are likely to feel out of proportion to the input, and the result is a chain of seemingly out-of-proportion responses that result in things growing exponentially in a way that both would agree is out-of-proportion.

It gets worse, though -- there's the feelings of responsibility. Person A knows that her system is stable; by itself, it doesn't produce out-of-proportion results. So, from her perspective, the problem is that Person B is reacting out-of-proportion. Person B, of course, sees the opposite, for equivalent reasons. Thus, it's natural for both Person A and Person B to look at the other's reactions for the problem, and to blame the other for the fact that things blow up uncontrollably.

### Solutions

Granted that there exist cases of someone much like Person A and someone much like Person B who wish to have a relationship with one another, it's reasonable to ask how such a relationship can be made to work, without blowup.

I believe that it's most workable to consider altering the links from how the

`x`of one person becomes the

`F(x)`of the other. Both of these links are shared territory; they contain the system of one person that reports their

`x`as a

`z`to the other person, and the system of the other person that takes in that

`z`and converts it to a

`F(x)`. Changes can be made at both ends of this; although the model doesn't yet include it, one can produce an "output signal" that is not exactly one's

`x`value, but is instead a somewhat modified version of it. And, of course, one can work on changing one's controller coefficients. (It is not to be pretended that these are

*easy*changes; the latter in particular is difficult.)

In any case, the system can be stabilized by increasing the values of

`Cd`that apply to both links. In the link from Person A to Person B, the derivative-related input produces a down-spike after each up-spike from Person A, and that clears the input back out of Person B's integral-buffer. In the opposite link, it converts the bump back into a spike that Person A can deal with -- the bumps tend to rise quickly and decay slowly, and thus their derivative is a short spike up and a longer-lasting, slightly-negative value.

The effective

`Cd`can be increased in two ways. Beyond the obvious one of increasing it directly, it's also possible for each person to adjust their reporting -- instead of reporting simply

`x`to person B, person A will report

`x`plus some quantity of the time derivative of

`x`, and vice versa.

In practice, this means the following: Person A will, upon noticing that she's done spiking, tell Person B that she's done, so that he can clear it out of his integral buffer and stop reacting to it. And Person B will consider that Person A tends to spike, and thus clear things out of his integral buffer when the direct input stops. Meanwhile, Person B can report the times when he's starting to have an emotional bump, moreso than when it's continuing; Person A will react more to the start of the bumps rather than the bumps themselves.

This does, in fact, seem like a useful solution in actual practice. When Person B realizes that Person A's reaction is over when the spike ends, he will realize that it's not nearly as large an emotional reaction as a bump that high (and of the duration he expects) would be, and so he won't have as much of a reaction to it -- with luck, his bump will have barely even started at that point. Meanwhile, when Person A realizes that Person B is reacting to stuff that's some time previous, she won't have a spike in response to the fact that Person B's reaction seems far out of proportion to what she last said