Control via Fuzzy Logic

The previous chapter, The Basics of Control Theory, designed controllers by exact mathematical means — for instance choosing the feedback gains of a linear feedback control so the controlled system ends up with the eigenvalues, and hence the stability and response, we want. That approach is precise, but it is not always intuitive: it tells you which matrix to build, not in plain words why the controller acts the way it does, and it leans on having a mathematical model accurate enough to compute with.

Fuzzy logic is a different apparatus for the same job. Instead of sharp numerical thresholds it reasons with graded, human-readable notions like cold, lukewarm, and hot, and with intuitive IF–THEN rules an expert could state in words. Before we apply it to a control problem, we build up its vocabulary: fuzzy sets, the operations on them, and linguistic variables.

Crisp sets and fuzzy sets

Ordinary set membership is all-or-nothing: a given element is either in a set or it is not. Fuzzy logic relaxes exactly this, so the first thing it does is rename the ordinary kind of set to keep the two apart.

A fuzzy set keeps the same underlying collection of candidate elements but softens what “belongs” means.

The three-argument notation $\mu(x, X, \tilde A)$ keeps explicit which element ($x$), which underlying crisp set ($X$), and which fuzzy set ($\tilde A$) we are asking about — useful once several fuzzy sets live over the same $X$.

Two special cases tie the new notion back to the familiar one. Viewing the whole crisp set $X$ as a fuzzy set over itself gives full membership everywhere, $\mu(x, X, X) = 1$ for all $x \in X$; and any ordinary crisp set $A$ is just the special fuzzy set whose membership is $1$ on its elements, $\mu(x, X, A) = 1$ for all $x \in A$ (and $0$ off it). So crisp sets are the corner case of fuzzy sets where the only degrees used are $0$ and $1$.

Two derived notions pick out parts of a fuzzy set by their degree of membership.

A closely related operation does not throw the low-membership elements away but instead caps every degree at the level $\alpha$.

The distinction between the two is worth fixing: the $\alpha$-cut discards elements below the level $\alpha$ but leaves the surviving degrees alone, whereas the cut fuzzy set keeps every element but flattens the top of the membership function at height $\alpha$. The cut fuzzy set is the one that does the work later, when a partly-satisfied rule is only allowed to fire partly.

Shapes of the membership function

Once the framework is in place, the essential modeling task is concrete: defining the shape and values of the membership function for each fuzzy set. This is where the modeler’s knowledge enters. The plain $0$-to-$1$ leap recovers ordinary crisp sets; everything in between is a design choice, and many shapes are imaginable — piecewise linear, piecewise polynomials of higher degree, and so on. Available fuzzy-logic systems offer a handful of simple, ready-made options.

A useful way to read any of these shapes: plotted with the element $x$ on the horizontal axis and the degree $\mu$ on the vertical axis, a vertical side is an abrupt jump between full and zero membership — a crisp boundary — while a sloped side is a transition region of graded, partial membership, where the answer to “does $x$ belong?” is “somewhat”. The shapes below differ mainly in how wide and how smooth they make those transition regions.

• rectangle — both sides vertical, no transition region at all. This is just a crisp set drawn as a membership function: full membership inside the interval, none outside.
• triangle — often isosceles, but not necessarily. Membership rises linearly to a single peak at $1$ and falls back, so the two sloped sides are pure transition regions meeting at one fully-typical value.
• trapezoid — often symmetric, but not necessarily. Like a triangle but with a flat top: a band of values at full membership $1$, flanked by two linear transition regions.

Smoother and one-sided shapes round out the catalog:

• S-form and Z-form — typically used for one-sided delimited terms, where membership saturates at one end. An S-form rises from $0$ to $1$ as $x$ increases (e.g. “large”, which only gets more true the bigger $x$ is); a Z-form is its mirror, falling from $1$ to $0$.
• bell curve — often used for both-sided delimited terms: membership is high over a central band and tapers smoothly to $0$ on either side, like a rounded trapezoid.
• Also common are polygonal lines and a sinus half-period for the rising and falling flanks.

Operations on fuzzy sets

To reason with fuzzy sets we need counterparts to the standard set operations (and, equivalently, the logical connectives) — an intersection, a union, and a complement. There is wide scope in how to realize them concretely, adjustable to the application, but one restriction keeps the whole framework honest: the usual rules of logic must still hold in the crisp limit case, where every membership function is identically $1$ or identically $0$ ($\mu \equiv 1$, $\mu \equiv 0$). Fuzzy logic is meant to extend crisp set theory, not to replace it with something unrelated, so whatever definitions we pick must reduce to ordinary intersection, union, and complement when the degrees collapse back to $0$ and $1$.

The standard choices are the simplest ones that pass that test.

Linguistic variables

Working directly with membership functions is precise but unwieldy. To give an expert something intuitive to reason with, fuzzy control groups the fuzzy sets over one quantity under everyday words — cold, warm, hot — and treats those words as the values a variable can take.

For example, a linguistic variable named temperature has the temperature scale as its crisp set and a term set such as freezing cold – cold – neutral – lukewarm – warm – hot; a linguistic variable named color has a frequency range (roughly $400\text{–}800\,\mathrm{nm}$) as its crisp set and terms like green – yellowish-green – yellow-green – greenish-yellow – yellow.

Two design decisions come up immediately, and both are matters of modeling judgment rather than fixed rules. How many terms? Enough to express the distinctions the model needs, but not so many that neighboring terms can no longer be told apart. What shape for each term? Any of the membership-function shapes above, chosen to fit how the quantity behaves.

Fuzzy control systems

With this vocabulary in hand — fuzzy sets, their operations, and linguistic variables — fuzzy logic can be turned into a controller. A fuzzy control system is today very common, especially in consumer products like washing machines, dishwashers, and cameras, where the control task does not demand high precision. Its appeal comes from three places:

• No mathematical model needed. For many processes there is no model available, or the available one is far too complex to be useful. The previous chapter, The Basics of Control Theory, considered only the comparatively simple case of a system of homogeneous linear ODEs; the real world is usually much more complicated, and handling it by exact mathematics demands considerable effort. A fuzzy controller sidesteps the need for such a model.
• Modest mathematics. Building one is possible with little more than “school mathematics” — no eigenvalue analysis, no matrix algebra.
• Intuitive rules. The behavior is specified by linguistic, colloquial IF–THEN rules of the kind a human expert can simply state in words, which makes the controller easy to design and easy to read.

Inside the controller everything is evaluated fuzzily, but the two ends of the chain are firmly crisp: at the very beginning a sensor delivers a crisp value (a measured temperature, say), the fuzzy apparatus takes the detour through its fuzzy world, and at the very end the result is translated back into a crisp value — the setting actually applied to the actuator.

Every fuzzy controller is built from the same four steps, run in order:

1. Fuzzification — translate the crisp measured quantities into the fuzzy world: define the linguistic variables, their terms, and the membership functions, and read off the degree of membership of each measured value.
2. Rule base — the IF–THEN rules relating the variables, drawn from expert knowledge.
3. Inference — apply suitable inference operators to carry the fuzziness of the measured variables over to the control variables.
4. Defuzzification — collapse the resulting fuzzy control values back into crisp control values.

We follow these four steps through one running example: controlling a cooling valve. The state variable is the temperature $T$, and the control variable is the position $K$ (taking concrete values $k$) of the cooling valve — how far it is opened. Throughout, a capital letter ($T$, $K$) names the linguistic variable together with the crisp scale it lives on, while the matching lowercase letter ($t$, $k$) denotes a concrete crisp value on that scale.

Step 1: Fuzzification

The general principle of fuzzification is short:

• the measured values originate from crisp sets — each measured quantity is a linguistic variable with its own scale;
• for every linguistic variable there are several fuzzy sets, its linguistic terms, laid out to match human perception;
• for every measured value we determine its degree of membership in all of those terms.

So a single sharp reading does not pick out one term — it produces a whole profile of degrees. Measure $17^\circ$, for instance, and we ask to what degree that reading counts as low, as medium, and as high, getting a number in $[0,1]$ for each.

In the cooling-valve example a temperature value $t$ has been measured, and two linguistic variables (each with its own fuzzy sets) are in play: the temperature $T$, with terms low, medium, high; and the valve position $K$, with terms almost closed, ajar, almost open over the position scale $k$. The temperature is what we measure; the valve position is what we will ultimately control.

Fuzzifying the reading $t$ against the temperature terms gives its degrees of membership, e.g.

The reading is largely low, somewhat medium, and not at all high — the overlapping terms let it count as more than one thing at once.

Step 2: The rule base

The second step encodes the controller’s behavior as rules, and like the membership-function shapes it draws on domain expertise. Its pieces are:

• an elementary condition of the form $X = \tilde A$ — a linguistic variable $X$ (on its crisp set) set equal to one of its fuzzy sets (terms) $\tilde A$. Read it as “the variable $X$ currently takes the term $\tilde A$”, e.g. "$T = \text{low}$" means “the temperature is low”;
• a logical connection of elementary conditions through the usual operators AND, OR, NOT;
• a triggered action of the form $Y = \tilde B$ — a linguistic variable $Y$ set to a term $\tilde B$.

Putting these together gives rules of the form

with their respective linguistic variables and terms. The double subscript on $\tilde A_{1,j}$ keeps the bookkeeping straight: the first index says which input variable the condition is about, the second says which rule it belongs to.

For the cooling valve a small rule base suffices to illustrate the mechanics:

• rule 1: IF $T = \text{low}$ THEN $K = \text{ajar}$ (half-open);
• rule 2: IF $T = \text{medium}$ THEN $K = \text{almost open}$.

Step 3: Inference

Inference is where the fuzziness of the measured value is carried across to the control variable — in this example the valve position $K$, the quantity the controller will ultimately set. At the measured value we first calculate the degree of membership $\mu(x, X, \tilde A)$ for each elementary condition (each $X = \tilde A$ clause of an IF-part, e.g. $T = \text{low}$), and then combine those degrees according to the rule’s connectives, the logical operators AND, OR, and NOT that join the conditions:

• AND as the intersection of fuzzy sets — the minimum of the membership degrees;
• OR as the union of fuzzy sets — the maximum of the membership degrees;
• NOT as the complement — one minus the membership degree.

A single elementary condition just reads off the one degree of the term it names: $T = \text{medium}$ contributes the number $\mu(t, T, \text{medium})$ and nothing else, and how strongly the reading belongs to the other terms (low or high) plays no part in it. The connectives (AND, OR, NOT) then fold several such degrees into one, using the minimum, maximum, and complement rules just listed. The net effect is that the entire IF-part (the left side of the rule) collapses to a single fuzzy membership degree $\mu_j$. Informally the rule has become “IF $\mu_j$ THEN …”, and that one number measures how strongly the rule’s premise is met.

The obvious inference strategy then propagates that strength to the conclusion: the value $\mu_j$ of the IF-part limits the membership degree of the fuzzy set $\tilde B_j$ in the THEN-part. The reasoning is that an only partly fulfilled premise should imply an only partly executed conclusion. Concretely, for each rule $j$ we form the cut fuzzy set $\tilde B_j \uparrow \mu_j$ — the action’s membership function, capped at the height $\mu_j$.

Back to the example. Each of the two rules has a single condition, so its IF-part degree is read straight off the fuzzification:

• rule 1 yields $\mu_1 = \mu(t, T, \text{low})$ — about $0.85$ at the measured $t$ — and caps its action accordingly: $\text{ajar} \uparrow \mu_1$;
• rule 2 yields $\mu_2 = \mu(t, T, \text{medium})$ and caps its action: $\text{almost open} \uparrow \mu_2$.

Because $\mu_1$ is large the ajar term is barely cut, while the smaller $\mu_2$ cuts the almost open term down hard. What remains is, for each rule, a flat-topped fuzzy set over the valve scale $k$. Turning these into a single crisp valve position is the job of the fourth and last step.

Step 4: Defuzzification

The final step turns the fuzzy outcome back into a crisp setting. By the time inference is done, every rule that fired has handed back a clipped term over the valve’s opening scale: in our example rule 1 returned ajar (but only up to the height $\mu_1$) and rule 2 returned almost open (up to the height $\mu_2$). It helps to picture these on one axis — the horizontal axis is the valve opening (a position on it is the value $k$, running from fully shut on the left to wide open on the right), and the height above each opening is the degree to which that opening is currently endorsed. Defuzzification is the job of boiling all of these partial, overlapping verdicts down to a single number: the one opening we will actually set the valve to.

The first thing to settle is what to do when several rules reach for the same term. Suppose three rules had all concluded almost open, each with its own strength — one at $0.3$, one at $0.5$, one at $0.7$. We do not add them up or average them; we keep the strongest, taking at every opening the maximum of their degrees. This is the fuzzy union, and the reasoning is plain: a term is called for as strongly as the most confident rule that calls for it, so almost open ends up endorsed at $0.7$ and the weaker duplicates add nothing. It is the same pointwise maximum that stood for OR inside a rule’s premise, now merging rules that agree on a conclusion rather than combining conditions within one premise. And notice what it runs over: all the almost open verdicts are folded together, and separately all the ajar verdicts are folded together — the union is not trying to blend ajar into almost open.

After that merging, each concluded term is left with a single clipped shape — one for ajar, one for almost open. These sit in different stretches of the opening axis (ajar around a half-open position, almost open nearer wide open), so putting them together is mostly just laying both shapes on the same axis at once; only where two happen to overlap does the same maximum keep the higher one. The combined picture that results is the accumulation: one fuzzy shape over the whole opening range that carries every rule’s conclusion together.

Reconciling those different terms into a single opening is then a separate step, and it is the part that actually produces the crisp number. Rather than merging ajar and almost open into each other, it picks the one opening that best represents the whole combined shape. In the running example there is just one ajar rule and one almost open rule, so the union has no duplicates to merge — it simply places $\text{ajar} \uparrow \mu_1$ and $\text{almost open} \uparrow \mu_2$ side by side on the opening axis — and all the real work falls to this final step. Whichever way it is taken, the answer is a position on the opening axis, and everything being averaged along the way is likewise a position on that axis, never a degree of membership. In particular, the “maximum” and “minimum” in the first two methods below are the largest and smallest opening in a support — the right and left ends of the stretch where the shape has any height at all — and not the peak and floor of its height. There are several ways to take it:

• the mean of the maximum and minimum of the support of the fuzzy union — find where the accumulated shape starts and where it stops, and take the midpoint of those two openings. If it runs from $20\%$ to $90\%$, the crisp answer is $55\%$. Only the outer boundaries count: how many terms fired, where they sit inside that stretch, and how strongly each one fired all drop out;
• the mean of the maximum and minimum of the supports of the individual cut fuzzy sets — the same endpoint-midpoint, but computed per term first and only then averaged. If ajar’s support runs from $20\%$ to $60\%$ it contributes the representative opening $40\%$, and if almost open’s runs from $70\%$ to $90\%$ it contributes $80\%$; the mean of those two representatives is $60\%$. Because every active term hands in one position of its own, this method does register how many terms fired and where each of them lies, which the outer envelope of the first method cannot see;
• the centroid of the accumulated area — its balance point, which leans toward whichever term fired more strongly and so contributes the most area;
• the weighted centroid, for weighted rules — the same balance point, but with each rule’s contribution additionally scaled by an importance weight.

The most common collapse is the centroid. Writing $x$ for a value from the output range (the prospective control value), $\mu(x)$ for the membership function of the fuzzy union, $g_j$ for the weight of rule $j$, $\mu_j$ for the result of the IF-part of rule $j$, and $F(\tilde A)$ for the area under the membership function of fuzzy set $\tilde A$, the $x$-coordinate $x_S$ of the centroid is

This is just the center of gravity (balance point) of the area under the accumulated membership function, projected onto the output axis. When the rules carry different weights, one instead takes the weighted average of the individual centroids,

where $x_{S,j}$ is the centroid of rule $j$‘s own cut fuzzy set and its weight $\omega_j$ folds together the cut set’s area $F(\tilde B_j \uparrow \mu_j)$, the rule’s firing degree $\mu_j$, and the design weight $g_j$.

For the cooling valve we now have two cut fuzzy sets over the valve scale: $\text{ajar} \uparrow \mu_1$ (barely cut, since $\mu_1$ is large) and $\text{almost open} \uparrow \mu_2$ (cut hard, since $\mu_2$ is small). Accumulating them by fuzzy union and taking the centroid of the combined area gives a point $S = (k_S, \mu_S)$; its $k$-coordinate $k_S$ is the crisp answer, and the valve is adjusted to that position. The simplest alternative — the mean of the maximum and minimum of the support — would instead just average the outer boundaries of the accumulated region.

Example: the inverted pendulum

A classic test problem for any control method is the inverted pendulum (also called a balanced pole): a rigid pole stands on a cart, hinged at its base so that it can only tip along the single direction the cart is free to move. The cart, of mass $m_W$, rolls left and right on a track, and we may push it with a horizontal force $u$ in either direction. Left to itself the pole topples; the control task is to drive the cart back and forth so that the pole stays balanced upright.

The state of the system is captured by a few quantities: the angle $\varphi$ of the pole away from vertical, the rate $\dot\varphi$ at which that angle is changing, the cart’s horizontal displacement $s$ (written $s(t)$ as it varies in time), and the cart’s velocity $\dot s$.

Classical modeling attacks this by writing the mechanics down directly. Balancing the horizontal and vertical forces on the pole’s center of mass, accounting for its rotational motion, and balancing the horizontal motion of the cart give four equations, which together form a system of four linear ordinary differential equations in the unknowns $\varphi$, $\dot\varphi$, $s$, and $\dot s$.

A fuzzy controller for the pendulum

Designing a controller for that model — even a linear feedback control — is relatively involved. Fuzzy control offers an alternative that sidesteps the model altogether: describe the situation in plain words and write down a handful of intuitive IF–THEN rules. The controller works with three linguistic variables:

• the angle $\varphi$, with terms negative, zero, positive;
• the angular velocity $\dot\varphi$ (the rate of change of the angle — how fast, and in which direction, the lean is shifting), with terms negative, zero, positive;
• the actuating force $u$ (the manipulated variable — the horizontal push applied to the cart), with terms large negative, negative, zero, positive, large positive.

To read the terms we fix a sign convention. We take the angle $\varphi$ positive for a lean to the right (so that it grows rightward like the track’s own left-to-right axis), making a negative $\varphi$ a lean to the left and $\varphi = 0$ the upright position. The force $u$ is then taken positive in the opposite direction — a push to the left — and with that choice the table below comes out so that the controller always drives the cart toward the side the pole leans (the note below sorts out what here is a free convention and what is actually fixed). The angular velocity follows from the angle: $\dot\varphi$ positive means $\varphi$ is increasing, i.e. the pole is tipping further toward the right.

The rules pair the angle with the angular velocity using a simple AND, nine in all — one for each combination of a $\varphi$ term with a $\dot\varphi$ term. A representative one is

Behind all nine sits a single intuition: push the cart toward the side the pole is falling, sliding the support back under the toppling mass, and push harder the faster it is going over. A pole leaning left and still falling left calls for the strongest push left (large positive); one that is upright and steady calls for nothing at all (zero); and a lean that is already correcting itself needs only a gentle nudge. The example rule above is one such gentle case: the pole leans left ($\varphi$ negative) but its angle is already increasing back toward vertical ($\dot\varphi$ positive), so a moderate push toward that side (positive, a leftward push) suffices.

All nine rules are collected in a single table — the columns are the angle $\varphi$, the rows the angular velocity $\dot\varphi$, and each entry is the actuating force $u$ the rule prescribes:

The two far corners are the clearest: a pole leaning left and falling further left (both $\varphi$ and $\dot\varphi$ negative) gets the strongest push left, large positive; a pole leaning right and falling further right (both positive) gets the strongest push right, large negative. The center cell, upright and not moving, prescribes zero, and everything in between grades smoothly between these extremes.

Summary

Pulling the pieces together, a fuzzy control system runs each cycle as a fixed process chain that carries a crisp measurement into the fuzzy world, reasons there, and emerges with a crisp setting:

• read the crisp measured value for each input variable;
• fuzzification — set up the fuzzy world: the linguistic variables with the fuzzy sets of their terms, and the degree to which each measured value belongs to each term;
• rule base — the IF–THEN implications that hold in that fuzzy world, drawn from expert knowledge;
• inference — for each rule, reduce its IF-part to a single degree of membership, then use that degree to cut the fuzzy set of its THEN-part down to a cut fuzzy set;
• defuzzification — for each control variable, take the fuzzy union of those cut fuzzy sets to recover one fuzzy set over the variable, and find the center of gravity of that accumulated area to read off a single crisp control value;
• set each control variable to its crisp control value.