“Gee, Mr Wizard, in fuzzy-logic systems, a ‘hedge’ modifies a membership function. Isn’t that right?”

“That’s what it does, Jenny. For example, if you have a membership function for the fuzzy value hot, then the hedge very could be used to define a new membership function, very hot, which is a modified form of hot.”

‘‘But, why do they call it a hedge, Mr Wizard?”

‘‘That’s a very good question, Jenny. Let’s look up hedge in the dictionary and find out.”

“Gee, Mr Wizard. Okay!”

(Pause while Mr Wizard thumbs through his 2129-pg, umpteen-hundred-thousand word, 10-lb, Webster’s Unabridged New Twentieth Century Dictionary, Second Edition.)

“Ah, here it is, Jenny. Hedge (n): a thicket of thorn bushes. No, that’s not it. How about: ‘anything serving as a fence or barrier’? No, it’s not that either. Let’s try verbs. ‘Hedge (v): to enclose with a hedge.’ Nuts. ‘To hide behind words; refuse to commit oneself.’ Double nuts.”

‘‘Gee, none of those definitions fit, Mr Wizard!”

“Quiet, Jenny. Um, let’s see. How about this one: ‘to try to avoid or lessen loss by making counterbalancing bets, investments, etc.’ Well, shucks!” (A long pause while Mr Wizard continues to look through the dictionary.)

“Gee, Mr Wizard. Are those all the definitions?”

“It looks like it, Jenny. They have hedge bells, hedge berries, hedge bills, hedge funds, hedge garlic, hedgehogs, and a bunch of other hedges, but not the one we’re looking for.”

“Gee, Mr Wizard. So, why would anyone name a means of deriving new membership functions from already defined functions a ‘hedge’?”

‘‘I don’t know Jenny. But ‘hedge’ sounds like it should mean that.”

“You’re hedging, Mr Wizard.”

“I know I am, Jenny. Maybe one of our listening audience can explain this to us.”

An important part of fuzzy-system design is defining linguistic values for fuzzy variables, represented as membership functions. For example, the fuzzy values near, medium, and far might describe the relative distance to an elevator’s stopping point. To achieve greater precision, especially near critical operating points, the system designer often needs further refinement of a variable’s values, such as the fuzzy values very_near and very_very_near.

Although a designer can define fuzzy values that are independent of each other, they can also use a base fuzzy value—in this example, near—which can be modified by one or more hedges. The hedge becomes an adverb used to derive new membership functions from existing functions. For example, you can apply the hedge very to the value near to produce very near, and twice to produce very very near. If it’s well designed, you can apply that same hedge to different fuzzy values. For example, applying the hedge very to the fuzzy value far defines very far.

The fuzzy base value is a membership function of a crisp variable. The fuzzy value near is defined by a membership function:

A function also defines a hedge, with a base function, or an already hedged function, as its domain. If the function used to define very is

then the value very near becomes

and the value very very near is

You determine µ_{very very near}(x = x₀) by first calculating µ_near at x₀, then using the resulting value as the input to the function H_very, and finally using this resulting value again as input to H_very.

During design, if you modify the base membership function, any hedged values based on that function also change. The appropriateness of the change in the hedged values depends on the choice of the hedge function. Therefore, you must take care with hedge function definitions.

Last month I discussed two of the more popular functions used to define hedges, con and dil, which you may use to concentrate (compress) and dilate (expand) a base membership function. Expressed in terms of the base function µ(x), these functions are:

Fuzzy-system designers typically use con to define the hedge very and dil to define both roughly and its synonym, somewhat. Figure 1 shows the hedged values very near, very very near, roughly near, and roughly roughly near. Because con and dil are complementary, what one function does, the other undoes—that is, con(dil(f(x))) = f(x). In terms of fuzzy values, roughly very hot is simply hot.

Designers also use hedge functions (other than con and dil) to transform crisp values into fuzzy values. These are called “fuzzifiers,” but they should not be confused with the operation that transforms a crisp value into a truth value in a fuzzy set. Given a crisp value “x,” three hedged versions of x might be nearly x, a narrow fuzzy set; approximately x, a wider fuzzy set; and roughly x, a wider still fuzzy set. Each version is a fuzzy value that is derived from and centered at x.

You use a fuzzifying hedge when there is no appropriate word to describe the desired fuzzy value. For example, the various components of the 360º in a circle are not (in my experience) described in terms appropriate for fuzzy values. The use of a fuzzified crisp value (for example, roughly F) is both appropriate for system operation and highly descriptive. (Figure 2 shows examples of hedged (fuzzified) versions of F=180º).

The dominant-fuzzy-relational operator is IS, which is most often used to determine the degree to which a crisp input falls within a fuzzy set. As such, the operator IS is crisp and relates a crisp input or output value to a crisp degree of membership value µ.

The operator IS can also be hedged, thereby making its operation fuzzy, as in nearly IS, approximately IS, and roughly IS.

You can easily see how a hedged operator works by noting that the following two expressions achieve the same result. In fact, they are synonymous when an appropriate hedge function is chosen for roughly.

IF track_angle IS roughly 180º

and IF track_angle roughly IS 180º

In the first expression, roughly hedges the crisp value 180º, while in the second, it hedges the crisp operator IS. In both cases a fuzzy range is centered at 180º.

I like hedges. They add power and richness to both fuzzy system design and representation. In simple systems, it is often easier to ignore hedges and merely define separate, independent functions—as with the example very_near instead of very near earlier in the column. However, in complex systems, hedging fuzzy values becomes a principal means of reducing large numbers of membership functions. I have found hedging crisp values is often the only way to convert them to being fuzzy.

One more caution: if you apply a hedge to more than one fuzzy value, be certain the hedge does what you want it to, especially when you start modifying values to fine tune the system.

"Gee, Mr Wizard. Hedges really can add power to fuzzy logic system designs, can’t they?”

“Yes, they can, Jenny.”

“But, gee, Mr Wizard. I still don’t know why they call them ...”

“Thanks for stopping by, Jenny.”