Membership functions map input variables to a degree of membership, in a fuzzy set, between 0 and 1. If the degree of membership in a given set is 1, we can say the input for that set is absolutely true. If the degree is 0, we can say for that set the input is absolutely false. If the degree is somewhere between 0 and 1, it is true to a certain extent—that is, to a degree.

Before looking at fuzzy membership functions, let’s consider the membership function for Boolean logic. Figure 10-2 illustrates such a function.

Figure 10-2. Boolean logic membership function

Here we see that input values lower than x ₀ are mapped to false, while values higher than x ₀ are mapped to true. There is no in-between mapping. Going back to the weight example, if x ₀ equals 170 pounds, anyone weighing more than 170 pounds is overweight and anyone weighing less than 170 pounds is not overweight. Even if a person weighs 169.9 pounds, he still is considered not overweight. Fuzzy membership functions enable us to transition gradually from false to true, or from not overweight to overweight in our example.

You can use virtually any function as a membership function, and the shape usually is governed by desired accuracy, the nature of the problem being considered, experience, and ease of implementation, among other factors. With that said, a handful of commonly used membership functions have proven useful for a wide variety of applications. We’ll discuss those common membership functions in this chapter.

Consider the grade function illustrated in Figure 10-3.

Figure 10-3. Grade membership function

Here you can see the gradual transition from 0 to 1. The range of x-values for which this function applies is called its support. For values less than x ₀, the degree of membership is 0 or absolutely false, while for values greater than x ₁, the degree is 1 or absolutely true. Between x ₀ and x ₁, the degree of membership varies linearly.

Using the point-slope equation for a straight line, we can write the equation representing the grade membership function as follows:

Going back to the weight example, let’s say this function represents the membership for overweight. Let x ₀ equal 175 and x ₁ equal 195. If a person weighs 170 pounds, he is overweight to a degree of 0—that is, he is not overweight. If he weighs 185 pounds, he is overweight to a degree of 0.5—he’s somewhat overweight.

Typically, we’re interested in the degree to which an input variable falls within a number of qualitative sets. For example, we might want to know the degree to which a person is overweight, underweight, or at an ideal weight. In this case, we could set up a collection of sets, as illustrated in Figure 10-4.

Figure 10-4. Fuzzy sets

Point-slope Equation for a Straight Line

The equation for a straight line passing through the points (x₀,y₀) and (x₁ y₁) is:

where m is the slope of the line and is equal to:

With this sort of collection, we can calculate a given input value’s membership in each of the three sets—underweight, ideal, and overweight. We might, for a given weight, find that a person is underweight to a degree of 0, ideal to a degree of 0.75, and overweight to a degree of 0.15. We can infer in this case that the person’s weight is substantially ideal—that is, to a degree of 75%.

The triangular membership function shown in Figure 10-4 is another common form of membership function. Referring to Figure 10-5, you can write the equation for a triangular membership function as follows:

Figure 10-5. Triangular membership function

Figure 10-4 also shows a reverse-grade membership function for the underweight set. Referring to Figure 10-6, you can write the equation for the reverse grade as follows:

Figure 10-6. Reverse grade membership function

Another common membership function is the trapezoid function, as shown in Figure 10-7.

Figure 10-7. Trapezoid membership function

You can write the trapezoid function as follows:

Setting up collections of fuzzy sets for a given input variable, as shown in Figure 10-4, is largely a matter of judgment and trial and error. It’s not uncommon to tune the arrangement of set membership functions to achieve desirable or optimum results. While tuning, you can try different shapes for each fuzzy set, or you can try using more or fewer fuzzy sets. Some fuzzy logic practitioners recommend the use of seven fuzzy sets to fully define the practical working range of any input variable. Figure 10-8 illustrates such an arrangement.

Figure 10-8. Seven fuzzy sets

The seven fuzzy sets shown in Figure 10-8 are center, near right, right, far right, near left, left, and far left. These categories can be anything, depending on your problem. For example, to represent the alignment of player and nonplayer characters in your role-playing game, you might have fuzzy sets such as neutral, neutral good, good, chaotic good, neutral evil, evil, and chaotic evil.

Notice that each set in Figures 10-4 and 10-8 overlaps immediately adjacent sets. This is important for smooth transitions. The generally accepted rule of thumb is that each set should overlap its neighbor by about 25%.

The membership functions we discussed so far are the most commonly used; however, other functions sometimes are employed when higher accuracy or nonlinearity is required. For example, some applications use Gaussian curves, while others use S-shaped curves. These are illustrated in Figure 10-9. For most applications and games, the piecewise linear functions discussed here are sufficient.

Figure 10-9. Examples of other membership functions

Example 10-1 shows how the various membership functions we’ve discussed might look in code.

double     FuzzyGrade(double value, double x0, double x1)
{
      double result = 0;
      double x = value;
      if(x <= x0)
            result = 0;
      else if(x >= x1)
            result = 1;
      else
            result = (x/(x1-x0))-(x0/(x1-x0));
      return result;
}
double  FuzzyReverseGrade(double value, double x0, double x1)
{
      double result = 0;
      double x = value;
      if(x <= x0)
            result = 1;
      else if(x >= x1)
            result = 0;
      else
            result = (-x/(x1-x0))+(x1/(x1-x0));
      return result;
}
double     FuzzyTriangle(double value, double x0,
                               double x1, double x2)
{
      double result = 0;
      double x = value;
      if(x <= x0)
             result = 0;
      else if(x == x1)
             result = 1;
      else if((x>x0) && (x<x1))
             result = (x/(x1-x0))-(x0/(x1-x0));
      else
             result = (-x/(x2-x1))+(x2/(x2-x1));
      return result;
}
double     FuzzyTrapezoid(double value, double x0, double x1,
                                double x2, double x3)
{
      double result = 0;
      double x = value;
      if(x <= x0)
             result = 0;
      else if((x>=x1) && (x<=x2))
             result = 1;
      else if((x>x0) && (x<x1))
             result = (x/(x1-x0))-(x0/(x1-x0));
      else
             result = (-x/(x3-x2))+(x3/(x3-x2));
      return result;
}

To determine the membership of a given input value in a particular set, you simply call one of the functions in Example 10-1, passing the value and parameters that define the shape of the function. For example, FuzzyTrapezoid(value, x0, x1, x2, x3) determines the degree of membership of value in the set defined by x0, x1, x2, x3 with a shape, as shown in Figure 10-7.

Hedge functions are sometimes used to modify the degree of membership returned by a membership function. The idea behind hedges is to provide additional linguistic constructs that you can use in conjunction with other logical operations. Two common hedges are VERY and NOT_VERY, which are defined as follows:

Here, Truth(A) is the degree of membership of A in some fuzzy set. Hedges effectively change the shape of membership functions. For example, these hedges applied to piecewise linear membership functions will result in the linear portions of those membership functions becoming nonlinear.

Hedges are not required in fuzzy systems. You can construct membership functions to suit your needs without the additional hedges. We mention them here for completeness, as they often appear in fuzzy logic literature.

If we’re going to write logical rules given fuzzy input, we’ll need a way to apply the usual logical operators to fuzzy input much like we would do for Boolean input. Specifically, we’d like to be able to handle conjunction (logical AND), disjunction (logical OR), and negation (logical NOT). For fuzzy variables, these logical operators typically are defined as follows:

Here, again, Truth(A) means the degree of membership of A in some fuzzy set. This will be a real number between 0 and 1. The same applies for Truth(B) as well. As you can see, the logical OR operator is defined as the maximum of the operands, the AND operator is defined as the minimum of the operands, and NOT is simply 1 minus the given degree of membership.

Let’s consider an example. Given a person is overweight to a degree of 0.7 and tall to a degree of 0.3, the logical operators defined earlier result in the following:

In code, these logical operations are fairly trivial, as shown in Example 10-1.

double FuzzyAND(double A, double B) {
   	return MIN(A, B);
}
double FuzzyOR(double A, double B) {
   	return MAX(A, B);
}
double FuzzyNOT(double A) {
   	return 1.0 - A;
}

These are not the only definitions used for AND, OR, and NOT. Some specific applications use other definitions—for example, you can define AND as the product of two degrees of membership, and you can define OR as the probabilistic-OR, as follows:

Some third-party fuzzy logic tools even facilitate user-defined logical operators, making the possibilities endless. For most applications, however, the definitions presented here work well.

In a traditional Boolean logic application, rules such as if A AND B then C evaluate to absolutely true or false 1 or 0. After reading the previous section, you can see that this clearly is not the case using fuzzy logic. A AND B in fuzzy logic can evaluate to any number between 0 and 1, inclusive. This fact makes a fundamental difference in how fuzzy rules are evaluated versus Boolean logic rules.

In a traditional Boolean system, each rule is evaluated in series until one evaluates to true and it fires, so to speak—that is, its conclusion is processed. In a fuzzy rules system, all rules are evaluated in parallel. Each rule always fires; however, they fire to various degrees, or strengths. The result of the logical operations in each rule’s premise yields the strength of the rule’s conclusion. In other words, the strength of each rule represents the degree of membership in the output fuzzy set.

Let’s say you have a video game and are using a fuzzy system to evaluate whether a creature should attack a player. The input variables are range, creature health, and opponent ranking. The membership functions for each variable might look something like those shown in Figure 10-10.

Figure 10-10. Input variable membership functions

The output actions in this example can be flee, attack, or do nothing. We can write some rules that look something like the following:

You can set up several more rules to handle more possibilities. In your game, all these rules would be evaluated to yield a degree of membership for each output action. Given specific degrees for the input variables, you might get outputs that look something like this:

In code, evaluation of these rules would look something like that shown in Example 10-1, where you can see a distinct difference from traditional if-then style rules.

degreeAttack = MIN(MIN (degreeMelee, degreeUninjured),
                               1.0 - degreeHard);
degreeDoNothing = MIN ( (1.0 - degreeMelee),
                               degreeUninjured);
degreeFlee = MIN (MIN ((1.0 - degreeOutOfRange),
                              (1.0 - degreeUninjured)),
                              (1.0 - degreeWimp));

The output degrees represent the strength of each rule. The easiest way to interpret these outputs is to take the action associated with the highest degree. In this example, the resulting action would be to flee.

In some cases, you might want to do more with the output than execute the action with the highest degree. For example, in the threat assessment case we discussed earlier in this chapter, you might want to use the fuzzy output to determine the number, a crisp number, of defensive units to deploy. To get a crisp number as an output, you have to defuzzify the results from the fuzzy rules.