Fuzzy Logic: Theory, Inference, and Control

Course notes covering theory and practice from fuzzy sets and membership functions to Mamdani and Sugeno inference, fuzzy control, clustering, ANFIS, and type-2 systems.

Introduction

Many concepts in the real world do not have sharp boundaries. We may say that an environment is “hot,” a vehicle is “fast,” a risk is “high,” a project budget is “adequate,” or a service is “good,” yet the boundaries of these concepts are rarely separated by a single exact number.

Classical logic and classical set theory treat membership sharply:

member     → 1
not member → 0

In fuzzy set theory, an element may belong to a set with a particular degree of membership:

0 ≤ μA(x) ≤ 1

For example, an environment at 26 °C may be modeled as:

membership in WARM = 0.8
membership in HOT  = 0.4

The value 0.4 does not mean “there is a 40% probability that the air is hot.” It indicates the degree to which 26 °C conforms to the concept of “hot” within the chosen model.

This distinction is fundamental to fuzzy logic.

Fuzzy logic is particularly useful when:

boundaries are not sharp,
expert knowledge can be expressed through linguistic rules,
a complete mathematical model of the system is difficult or expensive to obtain,
measurements or concepts contain uncertainty or vagueness,
a rule base close to human decision-making is desired,
a nonlinear input-output relationship needs to be approximated.

Fuzzy logic, however, is not a universal method that “solves everything whenever uncertainty exists.” The choice of membership functions, rule base, scales, and inference method directly determines system behavior.

The aim of these notes is to explain fuzzy logic not only at a definitional level, but together with its mathematical foundations, inference mechanisms, control design, and current application tools.

1. Historical development

The starting point of fuzzy set theory is Lotfi A. Zadeh's 1965 paper “Fuzzy Sets.” In this work, Zadeh defined a structure in which set membership could be represented not only by 0 or 1, but by degrees between 0 and 1.

The 1965 paper:

L. A. Zadeh, “Fuzzy Sets,” Information and Control, 8(3), 338-353, 1965.

established the fundamental mathematical framework of fuzzy sets.

Important developments followed:

1965 → Fuzzy sets
1970 → Decision making in a fuzzy environment
1975 → Linguistic variables and approximate reasoning
1975 → Mamdani-Assilian fuzzy controller
1985 → Takagi-Sugeno system model
1993 → ANFIS / neuro-fuzzy learning

Bellman and Zadeh addressed decision making with fuzzy goals and fuzzy constraints in 1970.

Zadeh's 1975 work on linguistic variables established a mathematical basis for representing natural-language expressions such as “young,” “very hot,” or “approximately high” through fuzzy sets.

Mamdani and Assilian's 1975 work demonstrated the engineering importance of fuzzy control by converting the linguistic control rules of an expert operator into an automatic controller.

In 1985, Takagi and Sugeno introduced a different fuzzy modeling approach in which the consequent is a constant or a function of the inputs.

In 1993, J.-S. R. Jang's ANFIS work introduced an adaptive-network approach that can learn fuzzy-inference-system parameters from data.

This historical progression requires one important clarification:

Fuzzy set theory was not built on top of artificial neural networks in 1965.

The systematic integration of fuzzy logic and neural networks developed later in neuro-fuzzy systems.

2. Precision, uncertainty, and fuzziness

Scientific modeling traditionally seeks precise definitions. The real world, however, does not always consist of sharp boundaries.

For example:

When is a person tall?
When is a road congested?
When is a temperature high?
When is a risk unacceptable?

It is difficult to assign one universal threshold to many of these questions.

For example, a classical model such as:

height ≥ 170 cm → tall
height < 170 cm → short

is mathematically precise.

But:

169.999 cm → short
170.000 cm → tall

creates an artificial discontinuity in everyday conceptual use.

A fuzzy approach softens the boundary:

165 cm → tall membership 0.2
170 cm → tall membership 0.5
180 cm → tall membership 0.9

The membership values depend on the model design.

Rather than eliminating vagueness, fuzzy logic attempts to transform it into a numerical and processable representation.

3. Fuzziness and probability are not the same thing

This is one of the most frequently confused aspects of fuzzy logic.

3.1. Probability

Probability generally expresses uncertainty about whether an event will occur.

Probability of rain tomorrow = 0.30

The event itself has a crisp outcome:

it rains
or
it does not rain

The uncertainty lies in our knowledge before the event occurs.

3.2. Fuzziness

Fuzziness describes how strongly an object or state conforms to a concept.

Today's weather has membership 0.30 in the “cool” set.

The question is not:

Is the weather cool or not?

but:

To what degree is the weather cool?

Summary:

| Concept | Fundamental question | |---|---| | Probability | Will the event occur? | | Fuzziness | To what degree does the state fit the concept? |

A fuzzy membership degree is not a probability.

4. Crisp sets

Let X be a universal set and A a subset of it.

In a crisp set, the characteristic function is:

χA(x) = 1, x ∈ A
χA(x) = 0, x ∉ A

For example, if we define the set “hot” as:

A = {x | x ≥ 30 °C}

then:

29.9 °C → 0
30.0 °C → 1

The definition is mathematically clear.

But in many real-world problems involving gradual concepts, the transition is too abrupt.

5. Fuzzy sets

A fuzzy set A is defined by a membership function assigning each element of the universe a membership degree:

μA : X → [0,1]

Here:

μA(x) = 0

means the element does not belong to the set at all,

μA(x) = 1

means full membership, and

0 < μA(x) < 1

means partial membership.

A fuzzy set may be represented symbolically as:

A = {(x, μA(x)) | x ∈ X}

An important point is:

The membership degree is not a physical property of the object; it is part of the chosen conceptual model.

The same temperature can have different membership values in different contexts.

For example, 28 °C may be modeled as:

hot in terms of human comfort
cold in terms of an industrial furnace

6. Universe of discourse

The range over which a fuzzy variable operates is called the universe of discourse.

For room temperature:

X = [0, 50] °C

For vehicle speed:

X = [0, 200] km/h

Membership functions are defined over this range.

If the universe of discourse is chosen incorrectly, even well-designed membership functions and rules may produce unexpected behavior.

7. Membership function

The membership function is the bridge between a quantitative input and a linguistic concept.

For temperature, fuzzy sets such as:

COLD
WARM
HOT

may be defined.

Each is represented by a function:

μCOLD(T)
μWARM(T)
μHOT(T)

The same temperature may belong to multiple sets at the same time.

For example:

T = 24 °C

μCOLD(24) = 0.1
μWARM(24) = 0.8
μHOT(24)  = 0.3

This overlap allows fuzzy systems to produce smooth transitions instead of sharp thresholds.

8. Fundamental properties of membership functions

8.1. Support

The region in which membership is greater than zero:

support(A) = {x | μA(x) > 0}

8.2. Core

The region in which membership equals 1:

core(A) = {x | μA(x) = 1}

8.3. Boundary

The region of partial membership:

boundary(A) = {x | 0 < μA(x) < 1}

8.4. Height

The maximum membership degree of a fuzzy set:

h(A) = sup μA(x)

If:

h(A) = 1

the set is a normal fuzzy set.

9. Triangular membership function

This is one of the most common and computationally simple membership functions.

For parameters:

a < b < c

it is defined as:

           0                       x ≤ a
μ(x) =     (x-a)/(b-a)             a < x ≤ b
           (c-x)/(c-b)             b < x < c
           0                       x ≥ c

Graph:

μ
1          /
          /  \
         /    \
0 ______/_____________ x
       a   b    c

Advantages:

simple,
fast,
interpretable,
suitable for embedded systems.

10. Trapezoidal membership function

It is defined by four parameters:

a ≤ b ≤ c ≤ d

Shape:

μ
1        ______
        /      \
       /        \
0 ____/_______________ x
     a b        c d

It is particularly useful when a concept is considered fully valid over a range.

For example:

“normal temperature”

may be modeled with membership 1 over an interval.

11. Gaussian membership function

A Gaussian membership function is smooth and differentiable.

μ(x) = exp(-0.5 * ((x-c)/σ)^2)

where:

c → center
σ → spread

Gaussian functions are useful for:

smooth transitions,
optimization,
learning parameters from data,
neuro-fuzzy systems.

12. Other membership functions

Other functions used in fuzzy systems include:

sigmoid,
S-curve,
Z-curve,
generalized bell,
Pi-curve,
custom user-defined functions.

The shape of the membership function depends on the problem.

What matters is not graphical aesthetics, but:

whether it represents the intended input-output behavior correctly.

13. How should a membership function be selected?

Membership functions can be determined in several ways.

Expert knowledge

An expert might provide initial ranges such as:

0-15 °C very cold
10-25 °C cold
20-30 °C warm
25-40 °C hot

Data

Measurement data can be used to determine membership-function parameters through:

clustering,
optimization,
regression,
neuro-fuzzy learning.

Hybrid approach

The initial structure is defined by an expert and then adjusted using data.

This is often a good balance in engineering problems.

14. Alpha-cut

The elements of a fuzzy set above a particular membership level are represented by an α-cut:

Aα = {x | μA(x) ≥ α}

For example, if:

α = 0.7

only elements with membership degree 0.7 or greater are included.

Alpha-cuts help analyze a fuzzy set as a sequence of crisp sets.

15. Fuzzy numbers

Fuzzy sets defined over the real numbers, generally normal and convex, can be used as fuzzy numbers.

For example, the concept:

approximately 100

can be represented by the triangular fuzzy number:

(90, 100, 110)

This representation is used in areas such as:

cost,
duration,
estimation,
expert assessment,
multi-criteria decision making.

16. Linguistic variables

One of Zadeh's fundamental contributions to fuzzy logic is the concept of the linguistic variable.

Numerical variable:

Temperature = 27.3 °C

Linguistic variable:

Temperature = hot

A term set for a linguistic variable may be:

T(Temperature) = {
    very cold,
    cold,
    warm,
    hot,
    very hot
}

Each linguistic term corresponds to a fuzzy set.

17. Linguistic hedges

In natural language, words such as:

very
somewhat
quite
approximately
not

modify the meaning of a concept.

In fuzzy logic, these may be modeled as linguistic hedges.

For example, a classical approach may use:

μVERY_HOT(x) = μHOT(x)^2

This suppresses lower membership values and narrows the “very hot” set.

Similarly, an expansion may use:

μSOMEWHAT_HOT(x) = sqrt(μHOT(x))

These are not mandatory definitions; they are part of the chosen fuzzy-language model.

18. Fuzzy set operations

Classical set operations can be extended to fuzzy sets.

Complement

Standard complement:

μ¬A(x) = 1 - μA(x)

Intersection

Zadeh's standard intersection:

μA∩B(x) = min(μA(x), μB(x))

Union

Standard union:

μA∪B(x) = max(μA(x), μB(x))

For example, if:

μA(x) = 0.7
μB(x) = 0.4

then:

A AND B → min(0.7, 0.4) = 0.4
A OR B  → max(0.7, 0.4) = 0.7
NOT A   → 1 - 0.7 = 0.3

19. T-norm and T-conorm

min and max are not the only choices in fuzzy logic.

General intersection operations are expressed through the T-norm family, while union operations are expressed through T-conorm / S-norm families.

Example T-norms:

minimum:
T(a,b) = min(a,b)

product:
T(a,b) = a*b

Example S-norms:

maximum:
S(a,b) = max(a,b)

probabilistic sum:
S(a,b) = a + b - a*b

For:

a = 0.7
b = 0.4

we obtain:

min       = 0.4
product   = 0.28
max       = 0.7
probor    = 0.82

The choice of operator changes rule firing strengths and therefore system output.

20. Fuzzy relations

Classical relations can also be extended through membership degrees.

A fuzzy relation may be defined as:

R : X × Y → [0,1]

For example:

“x is close to y”

can be modeled as a graded relationship between two variables.

Fuzzy relations are important in:

inference,
decision making,
pattern matching,
control theory.

21. Relationship between fuzzy logic and multi-valued logic

Classical logic uses two values:

TRUE  = 1
FALSE = 0

In fuzzy logic, a degree of truth may lie in:

[0,1]

For example, the proposition:

“the weather is hot”

may be modeled with a truth degree of 0.65.

However, equating fuzzy logic only with “multi-valued logic” is incomplete.

Fuzzy systems also involve:

fuzzy sets,
linguistic variables,
membership functions,
inference rules,
approximate reasoning.

22. Fuzzy inference system

A Fuzzy Inference System (FIS) produces output from inputs through fuzzy rules.

General flow:

Crisp input
    ↓
Fuzzification
    ↓
Rule evaluation
    ↓
Inference
    ↓
Aggregation of rule consequents
    ↓
Defuzzification
    ↓
Crisp output

A classical Mamdani system has four basic components:

Fuzzifier
Knowledge / rule base
Inference engine
Defuzzifier

The same fundamental structure was also used in the 2019 course notes on which the source material was based.

23. Fuzzification

Fuzzification is the process of calculating the membership degrees of a crisp input in the relevant fuzzy sets.

For example, for:

Temperature = 27 °C

we might obtain:

μWARM(27) = 0.6
μHOT(27)  = 0.7

The input is no longer represented only as:

From the perspective of the inference system, it becomes:

27 °C → {WARM:0.6, HOT:0.7}

24. Rule base

The rule base carries expert knowledge in a fuzzy system.

General form:

IF <antecedent> THEN <consequent>

Example:

IF temperature is HOT
AND humidity is HIGH
THEN fan speed is FAST

Another example:

IF vehicle speed is SLOW
AND distance to target is FAR
THEN INCREASE motor power

Rules can express expert behavior in place of an explicit numerical model.

25. Antecedent and consequent

A fuzzy rule has two parts.

Antecedent

IF temperature is HOT AND humidity is HIGH

Consequent

THEN fan speed is FAST

The antecedent determines the degree to which the rule is active.

The consequent determines how that activation is transferred into the output space.

26. Rule firing strength

For example, let:

μHOT(T) = 0.7
μHIGH_HUMIDITY(H) = 0.4

and suppose AND uses min:

w = min(0.7, 0.4)
w = 0.4

This value is the rule's firing strength.

If product is used:

w = 0.7 * 0.4
w = 0.28

Thus the AND operator is not merely an implementation detail; it is a design decision that affects system behavior.

27. Mamdani inference system

Mamdani-type fuzzy inference is one of the best-known methods in engineering.

It was demonstrated by E. H. Mamdani and S. Assilian in 1975 in the context of steam-engine control.

A typical Mamdani rule is:

IF x is A
AND y is B
THEN z is C

where:

A, B → input fuzzy sets
C    → output fuzzy set

Examples:

IF budget is INSUFFICIENT
THEN risk is HIGH

or:

IF temperature is HOT
AND humidity is HIGH
THEN fan speed is FAST

28. Stages of Mamdani inference

Mamdani inference generally proceeds as follows:

1. Receive crisp inputs
2. Fuzzify inputs
3. Calculate firing strength of each rule
4. Apply implication to each rule consequent
5. Aggregate all rule outputs
6. Defuzzify the aggregated fuzzy output

Each stage should be considered explicitly.

29. Mamdani implication

Suppose a rule has firing strength:

w = 0.4

and consequent set:

FAST

Clipping

In a classical Mamdani approach:

μresult(z) = min(w, μFAST(z))

The membership function is clipped at level w.

Scaling

Alternatively:

μresult(z) = w * μFAST(z)

scales the membership function.

The two methods do not necessarily produce the same result.

30. Aggregating rule consequents

Many rules may affect the same output variable.

For example:

Rule 1 → FAST, degree 0.4
Rule 2 → MEDIUM, degree 0.7
Rule 3 → FAST, degree 0.2

These consequents are combined into a single output fuzzy set.

A common aggregation method is:

max

For every output point:

μagg(z) = max(μ1(z), μ2(z), ..., μn(z))

This operation is called aggregation.

31. Defuzzification

After Mamdani inference, the output is still a fuzzy set.

A physical system generally requires a crisp value such as:

motor power = ?
fan PWM = ?
valve opening = ?
green-light duration = ?

The process of obtaining a crisp number from a fuzzy output is called defuzzification.

32. Centroid method

One of the most common defuzzification methods is the centroid / center-of-gravity method.

For a continuous output:

            ∫ z μ(z) dz
z* = -------------------------
             ∫ μ(z) dz

This gives the geometric center of gravity of the aggregated fuzzy set.

With discrete sampling:

            Σ zi μ(zi)
z* = -------------------------
             Σ μ(zi)

may be used.

The source course notes likewise use the centroid method in their Mamdani examples.

33. Other defuzzification methods

Centroid is not the only option.

Bisector

Select the point that divides the area into two equal parts.

Mean of Maximum — MOM

Take the mean of all points having maximum membership.

Smallest of Maximum — SOM

Select the smallest value having maximum membership.

Largest of Maximum — LOM

Select the largest value having maximum membership.

Method selection should consider:

computational cost,
output precision,
system behavior,
real-time requirements.

34. Mamdani example: risk assessment

One of the main examples in the source notes is project risk.

Inputs:

Budget
Number of Employees

Output:

Risk

Linguistic sets:

Budget:
INSUFFICIENT
TIGHT
SUFFICIENT

Employees:
FEW
MANY

Risk:
LOW
NORMAL
HIGH

Example rules:

IF budget is SUFFICIENT
OR employees are FEW
THEN risk is LOW

IF budget is TIGHT
AND employees are MANY
THEN risk is NORMAL

IF budget is INSUFFICIENT
THEN risk is HIGH

For an input pair such as:

Budget = 70
Employees = 45

each input is evaluated in the corresponding membership functions.

Multiple rules may fire simultaneously.

This is one of the key differences between a fuzzy system and a crisp decision table.

35. Sugeno inference system

In the Takagi-Sugeno-Kang (TSK) approach, the consequent does not have to be a fuzzy output set as it is in Mamdani systems.

A first-order Sugeno rule may be:

IF x is A
AND y is B
THEN z = p*x + q*y + r

A zero-order Sugeno system uses a constant consequent:

z = c

For example:

IF budget is INSUFFICIENT
THEN risk = 90

36. Calculating Sugeno output

Let each rule have firing strength:

wi

and crisp consequent:

zi

The overall output is calculated as a weighted average:

             Σ wi * zi
z* = -------------------------
               Σ wi

For example:

w1 = 0.1, z1 = 20
w2 = 0.2, z2 = 50
w3 = 0.5, z3 = 80

then:

z* =
(0.1*20 + 0.2*50 + 0.5*80)
/
(0.1 + 0.2 + 0.5)

= 65

Therefore, Sugeno systems do not require a separate output-membership-set defuzzification stage in the classical Mamdani sense.

37. Zero-order and first-order Sugeno

Zero-order

IF x is A THEN z = c

Every consequent is constant.

Advantages:

simple,
fast,
suitable for embedded systems.

First-order

IF x is A AND y is B
THEN z = p*x + q*y + r

The output is a linear function of the inputs.

This structure is powerful for data-driven system identification and adaptive learning.

38. Mamdani versus Sugeno

| Property | Mamdani | Sugeno | |---|---|---| | Rule consequent | Fuzzy set | Constant or function | | Interpretability | Usually high | Consequent is more mathematical | | Defuzzification | Required | Weighted average | | Computation | Can be heavier | Usually faster | | Data-driven tuning | Possible | Especially suitable | | Human expert rules | Very natural | Antecedent natural, consequent mathematical | | Control | Common | Strong in dynamic and adaptive systems |

There is no universal rule that Mamdani is “more accurate” or Sugeno is simply “faster.”

The choice depends on the structure of the problem.

39. Tsukamoto inference

Another method, though discussed less often than Mamdani and Sugeno, is Tsukamoto inference.

In a Tsukamoto system, the fuzzy set in each rule consequent must have a monotonic membership function.

Each rule produces a crisp:

zi

from its firing strength:

wi

The final output is again calculated in a weighted-average-like form.

Tsukamoto can be viewed conceptually as lying between Mamdani and Sugeno, although its use is more limited.

40. There is no single correct inference method

Even with the same:

membership functions,
input values,
rule base,

using:

AND = min

instead of:

AND = product

or:

implication = min

instead of:

implication = product

may produce different results.

Changing the defuzzification method can likewise alter the output.

A FIS is therefore:

more than a list of rules.

Its complete definition includes at least:

input ranges
membership functions
rule base
AND method
OR method
implication
aggregation
defuzzification
scaling

41. How is a rule base designed?

A fuzzy rule base is generally created from three sources.

Expert knowledge

An operator or domain expert may provide rules such as:

IF error is large positive
AND error is increasing
THEN strongly increase control

Data

Rules can be generated by examining input-output examples.

Physical knowledge

Known system behavior constrains the rule logic.

For example, in temperature control:

IF the room is already very hot
THEN increase heater power

is physically nonsensical.

42. Rule explosion

When many membership functions are used for each input, the rule count grows rapidly.

For example:

3 inputs
5 membership functions per input

full combination:

5^3 = 125

rules.

With six inputs:

5^6 = 15,625

This is the rule explosion problem.

Possible approaches include:

fewer membership functions,
hierarchical FIS,
sparse rule bases,
data-driven rule generation,
feature selection,
connecting several smaller FIS components.

Modern tools also support structures such as FIS trees for this purpose.

43. Rule weights

Not every rule has to carry the same confidence.

A rule weight may be defined as:

0 ≤ wrule ≤ 1

For example:

IF vibration is HIGH
THEN failure risk is HIGH
Weight = 0.9

A weaker expert rule could be included with:

Weight = 0.5

Assigning arbitrary weights does not make a system more reliable.

Weights should be supported by:

expert rationale,
data,
optimization.

44. Scaling factors

Physical inputs in control systems are often normalized.

For example, let:

e  = physical error
Ge = input scaling gain

Then:

en = Ge * e

produces a normalized input.

Similarly:

Δen = Gde * Δe
Δu = Gdu * Δun

may be used.

Scaling factors can strongly affect fuzzy-controller behavior, much like controller gains.

45. Fuzzy control

The purpose of a controller is to drive a measured system output toward desired behavior.

Classical feedback:

Reference r(t)
      ↓
     (-) ← y(t)
      ↓
Error e(t)
      ↓
Controller
      ↓
Control u(t)
      ↓
Process
      ↓
Output y(t)

In a fuzzy controller, the controller block contains a rule-based FIS.

46. Error and change in error

Two very common fuzzy-control inputs are:

e(k)  = r(k) - y(k)

and:

Δe(k) = e(k) - e(k-1)

The output may be:

u(k)

or, in incremental form:

Δu(k) = u(k) - u(k-1)

This structure is also used in the temperature-control example in the source notes.

47. Why use change in error?

Error magnitude alone does not indicate the direction of system motion.

Suppose in two cases:

e = +5

In the first case, error is decreasing rapidly:

Δe < 0

In the second, error is growing:

Δe > 0

The same control action may not be appropriate in both cases.

The pair:

e
Δe

therefore carries both position and trend information.

48. Linguistic sets for control

A classical term set for error and change in error is:

NB → Negative Big
NS → Negative Small
ZE → Zero
PS → Positive Small
PB → Positive Big

A more detailed system may use seven terms:

NB
NM
NS
ZE
PS
PM
PB

More membership functions do not automatically mean better control.

As membership count increases, so do:

rule count,
tuning complexity,
computational load.

49. Example fuzzy-control rule

Depending on the sign convention, a rule may be:

IF error is PB
AND change in error is PS
THEN change in control is PB

Another rule may be:

IF error is ZE
AND change in error is ZE
THEN change in control is ZE

The rule table is not universal.

For example:

e = reference - measurement

and:

e = measurement - reference

require opposite sign conventions in the rule table.

Using a ready-made rule table outside its original context is therefore incorrect.

50. Fuzzy control versus on-off control

On-off control may behave sharply:

e > 0 → full power
e < 0 → off

Hysteresis can be added to reduce rapid switching.

Fuzzy control can instead produce graded behavior such as:

increase slightly
increase moderately
increase strongly
hold
reduce slightly

This can provide smoother control in uncertain and nonlinear systems.

51. Fuzzy control versus PID

A PID controller operates as:

u(t) =
Kp*e(t)
+ Ki*∫e(t)dt
+ Kd*de(t)/dt

PID is:

simple,
well understood,
widely used,
analyzable,
sufficient for many processes.

Fuzzy control can:

incorporate expert knowledge,
represent nonlinear behavior easily,
operate without a complete mathematical model.

However:

Fuzzy control is not automatically better than PID.

For a simple process where PID works well, a fuzzy controller may add unnecessary complexity.

52. Fuzzy PID

The two approaches can be combined.

For example, a fuzzy system may tune:

Kp
Ki
Kd

gains according to operating conditions.

Flow:

e, Δe
  ↓
Fuzzy tuner
  ↓
Kp, Ki, Kd
  ↓
PID
  ↓
Process

This is used in fuzzy PID / gain scheduling controllers.

53. The stability question

The source notes list the difficulty of stability analysis among the disadvantages of fuzzy systems.

This is partly correct.

Analytical stability methods are more direct for simple linear systems such as classical PID-controlled plants.

Fuzzy controllers can be harder to analyze because of:

many rules,
nonlinear surfaces,
piecewise behavior.

However, the statement:

“The stability of fuzzy systems cannot be analyzed.”

is incorrect.

Lyapunov-based methods, sector conditions, LMI approaches, and Takagi-Sugeno model-based stability analysis can be used.

54. Performance metrics

The quality of a fuzzy controller should not be judged only from its surface plot.

Control-system metrics may include:

rise time,
settling time,
overshoot,
undershoot,
steady-state error,
integral absolute error,
integral squared error,
control energy,
disturbance rejection,
noise sensitivity.

For example:

IAE = ∫ |e(t)| dt

and:

ISE = ∫ e(t)^2 dt

can be used.

55. Surface plot

For a two-input, one-output FIS:

z = F(x,y)

can be visualized as a three-dimensional surface.

This is useful for identifying:

discontinuities in the rule base,
excessively steep regions,
unexpected inverse behavior,
unused input regions,
control saturation.

The source notes examine examples such as:

budget
number of employees
risk

and:

speed
queue length
green-light duration

through surface plots.

56. Traffic-light example

The source notes include a two-input traffic-light example.

Inputs:

Main-road average speed: [0,60] km/h
Side-road queue length: [0,200] m

Output:

Green-light duration: [0,90] s

Linguistic values:

Speed:
SLOW
NORMAL
FAST

Queue:
SHORT
NORMAL
LONG

Green Duration:
SHORT
MEDIUM
LONG

Example rules:

IF speed is FAST
THEN green duration is LONG

IF speed is NORMAL
AND queue is SHORT
THEN green duration is SHORT

IF speed is NORMAL
AND queue is LONG
THEN green duration is LONG

The most instructive aspect of this example is not a single result value, but:

the input-output surface created by all rules together.

57. Tipping example

A classic problem frequently used when teaching fuzzy logic is:

service quality
food quality
→ tip

For example:

IF service is POOR
OR food is STALE
THEN tip is LOW

IF service is AVERAGE
THEN tip is MEDIUM

IF service is GOOD
OR food is GOOD
THEN tip is HIGH

This problem is suitable for demonstrating:

membership functions,
the OR operation,
Mamdani inference,
defuzzification.

58. Multiple-input systems

A FIS does not have to be:

1 input → 1 output

For example, a system may be constructed as:

Inputs:
soil moisture
soil temperature

Outputs:
motor operating time
motor speed

The source course notes from 2019 also include an application that produces motor speed and operating time from temperature and humidity inputs.

59. Multiple-output systems

Multiple outputs can be generated as:

F(x1, x2, ..., xn)
→ y1, y2, ..., ym

As the system becomes more complex, however:

rule interpretability,
number of rules,
interactions among outputs

can become difficult to manage.

Sometimes, several smaller FISs that feed one another are more manageable than one large multiple-output system.

60. Real-time embedded implementation

The source course notes contain an example in which a MATLAB-Arduino connection measures:

temperature
humidity

and produces:

motor PWM
motor operating time

A typical loop in a real-time fuzzy control system is:

Read sensors
↓
Scale to physical units
↓
Evaluate the FIS
↓
Clamp the output to safe limits
↓
Apply it to the actuator
↓
Wait for the next sampling instant

The FIS is not the only design concern. The system design must also include:

sensor calibration,
sampling time,
actuator saturation,
safety limits,
communication failures.

61. Sampling time

In a digital control system, the sampling period:

Ts

is a critical parameter.

Sampling that is too slow can produce:

delayed control action,
oscillation,
poor disturbance rejection.

Excessively fast sampling can produce:

unnecessary computational load,
increased sensitivity to sensor noise.

Using fuzzy logic does not eliminate this classical control-engineering problem.

62. Saturation and limits

A FIS should not produce physically impossible outputs such as:

motor power = 130%

If the actuator range is:

0 ≤ PWM ≤ 255

then the output must be limited accordingly.

Inputs falling outside the expected universe of discourse must also be handled.

For example:

expected temperature = [-20,50]
measured temperature = 75

The system behavior for this case should be defined in advance.

63. Practical sequence for FIS design

A useful starting sequence for an engineering problem is:

1. Define the control or estimation objective
2. Select the inputs
3. Select the outputs
4. Define the physical ranges
5. Define the scaling structure
6. Define the linguistic terms
7. Construct the membership functions
8. Build the rule base
9. Select the inference operators
10. Select the defuzzification method
11. Inspect the surface
12. Simulate
13. Test boundary cases
14. Tune the parameters
15. Validate on the real system

64. How should the number of membership functions be selected?

Increasing the number of membership functions makes the model more detailed.

However:

too many membership functions
→ too many rules
→ too many parameters
→ more difficult tuning
→ possible overfitting

For an initial design, many control problems can use an odd number of symmetric sets such as:

3
5
7

This is not a rule, however.

The structure of the data or process may require asymmetric memberships.

65. Overlap

Overlap between neighboring membership functions provides smooth transitions.

For example, if the sets:

COLD
WARM
HOT

do not overlap at all, the system approaches conventional threshold logic.

Excessive overlap, on the other hand, may cause many rules to fire strongly at the same time.

Good overlap should:

produce transitions in the input space that are smooth while remaining sufficiently discriminative.

66. Coverage

At least one meaningful membership function should be active for every possible input value.

For example, suppose:

X = [0,100]

but the membership functions cover only:

[0,30]
[40,60]
[70,100]

Then no rule may fire in the regions:

30-40
60-70

This is a design error.

67. Rule consistency

Rules can conflict:

IF temperature is HOT
THEN fan is FAST

and:

IF temperature is HOT
THEN fan is SLOW

If both rules are valid in the same context, they may produce unexpected behavior on the system surface.

Conflicts may arise from:

differences between expert opinions,
an incorrect rule,
missing context,
too few inputs.

Rule inspection is part of the design process.

68. Incomplete rule bases

It is not mandatory to write a rule for every input combination.

The source notes also emphasize that all possible combinations may not be necessary in practice.

An incomplete rule base should nevertheless be intentional.

The following question must be asked:

What happens if the system operates in a region for which no rule has been defined?

In some FIS implementations, no output may be produced or a default behavior may occur.

The operating space should therefore be tested.

69. Can fuzzy systems learn?

In a classical, manually designed Mamdani controller:

a person defines the membership functions,
an expert writes the rules,
the parameters remain fixed.

In that sense, the system does not learn by itself.

This does not justify the conclusion that:

“Fuzzy logic systems cannot learn.”

In modern fuzzy systems, the following can be tuned from data:

membership parameters,
Sugeno consequent coefficients,
rule weights,
and, in some cases, rule structure.

ANFIS is one of the best-known examples in this area.

70. ANFIS

An Adaptive-Network-Based Fuzzy Inference System (ANFIS) represents a Sugeno-type fuzzy inference system within an adaptive network structure.

In Jang's 1993 work, the system was presented as a structure capable of combining:

human knowledge through fuzzy rules,
numerical data through training samples.

Consider a simple two-input Sugeno system:

Rule 1:
IF x is A1 AND y is B1
THEN f1 = p1*x + q1*y + r1

Rule 2:
IF x is A2 AND y is B2
THEN f2 = p2*x + q2*y + r2

The ANFIS training process adjusts:

membership functions
+
consequent coefficients

according to the data.

71. ANFIS layers

In the classical ANFIS description, computation can be viewed through the following layers:

Input
↓
Membership degrees
↓
Rule firing strengths
↓
Normalized firing strengths
↓
Sugeno consequents
↓
Total output

For example:

w1 = μA1(x) * μB1(y)
w2 = μA2(x) * μB2(y)

then:

w̄1 = w1 / (w1+w2)
w̄2 = w2 / (w1+w2)

and:

f = w̄1*f1 + w̄2*f2

may be computed.

72. Purpose of neuro-fuzzy systems

A strength of neural networks can be expressed as:

learning from data

while a strength of fuzzy systems can be expressed as:

linguistic rule structure and interpretability

The objective of a neuro-fuzzy approach is to combine:

learnability
+
rule-based representation

As the number of parameters grows, however, the system may lose some of its original human interpretability.

The assumption that “fuzzy = always explainable” should therefore also be used with caution.

73. Training and overfitting

Tuning membership functions from data is useful.

As in conventional machine learning, however, problems can occur such as:

overfitting to training data,
distribution shift,
fitting to noise,
poor generalization.

In data-driven FIS design, the data should be separated into:

training
validation
test

sets.

74. Current MATLAB note: ANFIS

The MATLAB Fuzzy Logic Toolbox API has changed substantially since the 2019 source notes.

As of 2026, MathWorks marks:

anfis

as “not recommended” and recommends the following approach for new development:

tunefis(... Method="anfis")

Instead of moving old code directly into a new project, the current API should be checked.

75. Fuzzy C-Means

Fuzzy C-Means (FCM) is a fuzzy-membership form of the classical k-means approach.

In k-means, a sample is assigned:

to only one cluster

In FCM, the same sample may have memberships such as:

Cluster 1 → 0.7
Cluster 2 → 0.3

This approach is useful for data sets whose boundaries naturally overlap.

The fundamental ideas of FCM go back to Dunn's 1973 work, while its widely used algorithmic form is associated with Bezdek and colleagues.

76. FCM objective function

The classical FCM objective function is:

Jm =
Σ_i Σ_j uij^m ||xi - cj||²

where:

uij → membership of sample i in cluster j
m   → fuzziness coefficient
cj  → cluster center

Unlike classical k-means, memberships are graded subject to:

Σ_j uij = 1

77. Where can FCM be used?

image segmentation,
grouping sensor data,
pattern recognition,
customer segmentation,
grouping fault conditions,
generating initial membership functions for a FIS.

However, FCM:

requires the number of clusters in advance,
may be sensitive to outliers,
can be affected by initial conditions.

78. Fuzzy decision making

Bellman and Zadeh's 1970 work considered decision problems in which objectives and constraints are represented by fuzzy sets rather than crisp boundaries.

For example, each of the following statements can be modeled by a membership function:

cost should be low
performance should be high
risk should be acceptable

The overall suitability of a decision alternative can be evaluated through the intersection of:

objectives
∩
constraints

79. Fuzzy multi-criteria decision making

Real decision problems contain concepts such as:

very important
moderately important
approximately good
low risk
high cost

Converting these directly into crisp numbers is not always straightforward.

Fuzzy multi-criteria decision-making methods may use approaches such as:

Fuzzy AHP,
Fuzzy TOPSIS,
fuzzy weighted sum,
fuzzy compromise methods.

Adding the word “fuzzy” to a method name does not make the decision objective.

Membership functions and expert assessments still contain assumptions.

80. Type-1 and Type-2 fuzzy sets

The preceding sections of these notes describe Type-1 fuzzy sets.

In a Type-1 system:

x → one membership degree

is assigned.

For example:

μHOT(27) = 0.65

This can raise another question:

How certain are we about the value 0.65 itself?

Type-2 fuzzy sets were developed to model uncertainty in the membership degree itself.

81. Interval Type-2 fuzzy set

In an Interval Type-2 system, membership for an input may be an interval rather than a single number.

For example:

μHOT(27) ∈ [0.55, 0.75]

This interval can represent:

different expert opinions,
sensor uncertainty,
changing operating conditions,
uncertainty in the membership function.

The region between the upper and lower membership functions is called the:

Footprint of Uncertainty — FOU

82. Cost of Type-2 systems

Type-2 fuzzy systems can model additional uncertainty.

However:

computation is more complex,
type reduction is required,
the number of parameters increases,
tuning becomes more difficult.

It therefore cannot be said that a Type-2 system:

is automatically better than a Type-1 system.

Modeling the additional uncertainty should produce a meaningful performance benefit.

83. Type reduction

A Type-2 inference result generally passes through a type reduction stage before being converted to a crisp value.

Common methods include:

Karnik-Mendel,
Enhanced Karnik-Mendel,
IASC,
EIASC.

The current MATLAB Fuzzy Logic Toolbox supports Interval Type-2 Mamdani and Sugeno systems.

84. Fuzzy logic and artificial intelligence

Fuzzy logic is one of the historical symbolic and approximate-reasoning tools of artificial intelligence.

It is particularly useful as a bridge among:

expert knowledge
+
linguistic rules
+
numerical measurements

In modern artificial intelligence, fuzzy logic can be used in areas such as:

decision support,
control,
explainable models,
hybrid neural-network systems,
classification under ambiguity,
soft boundaries between data groups.

85. Difference between fuzzy logic and machine learning

A classical fuzzy system may operate through:

human-defined memberships
+
human-defined rules

Machine learning generally learns model parameters through:

data
+
loss function
+
optimization

A fuzzy system:

can be constructed with very little data,
can incorporate expert knowledge,
can be structurally interpretable.

Machine learning:

is powerful for high-dimensional patterns,
can learn relationships for which manually writing rules is difficult.

Hybrid systems can combine the two approaches.

86. Fuzzy logic and probabilistic models

Fuzzy and probabilistic models do not have to be competitors.

A single system may simultaneously contain:

measurement uncertainty → probabilistic
conceptual vagueness → fuzzy

For example, sensor measurement error may be modeled as:

T ~ Normal(25, 0.5²)

while the concept:

“hot”

may be represented by a fuzzy membership function.

Separating these two kinds of uncertainty is important for sound modeling.

87. When is fuzzy logic appropriate?

The following conditions are strong indicators:

experts can express control knowledge as verbal rules,
the system is nonlinear,
crisp thresholds create artificial behavior,
constructing a complete physical model is difficult,
an interpretable control surface is desired,
an approximate solution with low computational cost is needed.

88. When may it be inappropriate?

Another method may be preferable when:

an accurate and simple mathematical model of the system exists,
a strong analytical control method is readily applicable,
the problem is a very high-dimensional perception task,
writing meaningful rules is impractical,
membership functions remain entirely arbitrary,
formal guarantees are required for safety-critical assurance.

For example, manually writing thousands of fuzzy rules for object recognition in images is generally less suitable than modern deep-learning approaches.

89. Advantages

Strengths of fuzzy systems include:

They naturally represent concepts without crisp boundaries.
Expert knowledge can be transferred directly into a rule base.
They can construct nonlinear input-output relationships.
They can reduce the need for a complete mathematical model in complex systems.
Small systems can operate with low computational cost.
Inspectable rules can provide interpretability.
Sensor data and linguistic knowledge can be combined in the same system.
They can be used for control, prediction, decision making, and classification.

90. Limitations

Selection of membership functions can be subjective.
Rule-base quality can depend on expert quality.
The number of rules can explode as the number of inputs grows.
Stability and performance proofs can be harder than for classical linear controllers.
Incorrect scaling can invalidate otherwise reasonable rules.
Interpretability can disappear in very large rule bases.
A data-tuned system can overfit.
The physical meaning of fuzzy memberships can be misinterpreted.
Probability and membership degree can be confused.

91. The statement “does not require a mathematical model”

This statement appears as an advantage in the source course notes, but it should be read carefully.

A more precise statement is:

Fuzzy control can make it possible to design a controller for some problems using expert rules without requiring a detailed analytical process model.

This does not mean:

Mathematical reasoning or a system model is never needed.

The following still need to be understood:

input ranges,
physical limits,
dynamic behavior,
sampling,
delays,
stability,
safety limits.

92. Similarity to human reasoning

Fuzzy logic is suitable for processing expressions such as:

low
medium
high
approximately
hot
slow
high risk

In this respect, it provides a representation similar to verbal decision rules used by people.

It cannot, however, be claimed that:

Fuzzy logic has been proven to be an actual model of how the human brain works.

It is an engineering model.

Human cognition includes much broader processes such as:

probabilistic reasoning,
symbolic processing,
learning,
memory,
perception,
intuition.

93. Fuzzy logic and explainability

In a small system, a rule such as:

IF temperature is high
AND humidity is high
THEN fan is very fast

is readily understandable.

Fuzzy systems can therefore be useful for explainable artificial intelligence.

Explainability decreases, however, in systems with hundreds of inputs and thousands of rules.

Explainability should be assessed together with:

number of rules
semantic meaningfulness of membership functions
simplicity of the output surface

94. Fuzzy control in critical systems

Fuzzy controllers can be used in fields such as:

automotive systems,
industrial control,
robotics,
energy,
transportation.

For a critical system, working well in simulation is not sufficient.

The following conditions should be examined:

normal operation
boundary conditions
sensor failure
actuator saturation
noise
delay
communication loss
unexpected input

Fuzzy logic does not replace safety engineering.

95. Verification

A fuzzy system should be verified systematically.

Coverage test

Is an output produced throughout the entire input space?

Monotonicity test

Does the output decrease in a region where physics requires it to increase?

Boundary test

Is there abrupt behavior at membership boundaries?

Rule test

Does each rule fire in the expected region?

Surface test

Are there unexpected peaks or valleys?

Time-domain test

Is the control system stable under the actual dynamics?

96. Sensitivity analysis

Change a membership-function parameter by a small amount:

a → a + δ

and measure the change in the system output.

The same procedure can be applied to:

rule weights,
scaling gains,
the defuzzification method.

If a very small parameter change causes a very large output change, the system may be fragile.

97. Monte Carlo and scenario testing

If the inputs are noisy in the real system, randomized samples can be used for testing.

For example:

T = 25 ± sensor noise
Humidity = 60 ± sensor noise

The FIS can be evaluated for thousands of samples.

The following can then be observed:

output distribution,
limit violations,
control oscillation,
worst-case behavior.

Although fuzzy logic itself is not probability, this is an example of using probabilistic testing to verify a fuzzy system.

98. Current MATLAB Fuzzy Logic Toolbox

The 2019 course notes use the older API family:

newfis
addvar
addmf
addrule
FIS structure

These examples remain valuable historically and pedagogically, but they should not be used as the primary basis for new MATLAB versions.

The current object-based structure uses:

mamfis
sugfis
mamfistype2
sugfistype2
addInput
addOutput
addMF
addRule
evalfis

According to MathWorks documentation, support for the legacy FIS structure in core functions such as evalfis was removed as of R2024b.

99. Simple Mamdani example with current MATLAB

The following structure demonstrates the current object-based API:

fis = mamfis(Name="tip");

fis = addInput(fis,[0 10],Name="service");
fis = addMF(fis,"service","trapmf",[0 0 2 4],Name="poor");
fis = addMF(fis,"service","trimf",[2 5 8],Name="average");
fis = addMF(fis,"service","trapmf",[6 8 10 10],Name="good");

fis = addInput(fis,[0 10],Name="food");
fis = addMF(fis,"food","trapmf",[0 0 2 4],Name="bad");
fis = addMF(fis,"food","trapmf",[6 8 10 10],Name="good");

fis = addOutput(fis,[0 30],Name="tip");
fis = addMF(fis,"tip","trimf",[0 5 10],Name="low");
fis = addMF(fis,"tip","trimf",[10 15 20],Name="medium");
fis = addMF(fis,"tip","trimf",[20 25 30],Name="high");

rules = [
    "If service is poor or food is bad then tip is low"
    "If service is average then tip is medium"
    "If service is good or food is good then tip is high"
];

fis = addRule(fis,rules);

result = evalfis(fis,[8 7]);

The purpose of this example is not to teach MATLAB, but to show the current API equivalent of the structure used in 2019.

100. Inspecting FIS behavior in MATLAB

With current tools:

showrule(fis)

can be used to inspect rules,

plotmf(fis,"input",1)

membership functions, and

gensurf(fis)

the input-output surface.

Depending on the options used, evalfis can also provide intermediate inference results rather than only the final crisp output.

This is useful for debugging.

101. Current deployment options

The current Fuzzy Logic Toolbox supports use and deployment through:

MATLAB,
Simulink,
C/C++ code generation,
IEC 61131-3 Structured Text,
Type-1 FIS,
Interval Type-2 FIS,
FIS trees.

This shows that fuzzy logic is not limited to an educational MATLAB interface.

102. Implementing a fuzzy system in plain software

A special-purpose library is not mandatory for implementing a fuzzy inference system.

A simple Mamdani system can be written directly with:

membership(x)
min / max
rule evaluation
aggregation
centroid

For example, a triangular membership function can be implemented in Python-like pseudocode as:

def trimf(x, a, b, c):
    if x <= a or x >= c:
        return 0.0
    if x <= b:
        return (x - a) / (b - a)
    return (c - x) / (c - b)

In production, details such as:

division by zero,
equal parameters,
boundary behavior,
floating-point precision

must also be handled.

103. Computational cost

A small Mamdani system can be inexpensive on an embedded processor.

The cost increases approximately with:

number of membership functions
+
number of fired rules
+
output sampling resolution

A Sugeno system can be less costly in many real-time applications, particularly because it computes the result through a weighted average.

104. Fixed-point implementation

On a resource-constrained microcontroller, fixed-point arithmetic may be used instead of floating point.

For example, membership may be represented over:

0 ... 255

instead of:

0.0 ... 1.0

In that case:

min
max
multiplication
weighted average

can be implemented using scaled integers.

Overflow and quantization errors must nevertheless be analyzed.

105. Design mistakes

Common mistakes include:

Confusing probability with membership degree.
Failing to select the universe of discourse according to the physical range.
Leaving gaps between membership functions.
Using more membership functions than necessary.
Reversing the physical sign convention in the rule base.
Evaluating the system using only one example.
Failing to inspect the surface plot.
Ignoring sensor noise.
Leaving actuator limits to the FIS itself.
Assuming that “a fuzzy system thinks like a human.”
Using the legacy MATLAB API directly in new versions.
Accepting a learned FIS without validation data.

106. A practical engineering model for fuzzy logic

The following flow can be used for a problem:

Problem
↓
Are crisp thresholds actually a problem?
↓
Can meaningful linguistic variables be defined?
↓
Select inputs and outputs
↓
Define universes of discourse
↓
Construct membership functions
↓
Create rules from experts / data
↓
Choose Mamdani / Sugeno
↓
Select inference operators
↓
Surface analysis
↓
Simulation
↓
Performance measurement
↓
Sensitivity and boundary tests
↓
Validation on the real system

107. Exercise 1 — temperature memberships

For the range:

0-50 °C

design three membership functions:

COLD
WARM
HOT

Calculate the membership degrees of:

in each set.

Then explain why the memberships are not required to sum to 1.

108. Exercise 2 — distinction from probability

Distinguish the following two statements mathematically:

The probability of rain tomorrow is 0.7.

Today's weather belongs to the concept “rainy” with degree 0.7.

Explain why the two values of 0.7 do not have the same meaning.

109. Exercise 3 — Mamdani

Inputs:

Temperature: [0,50]
Humidity: [0,100]

Output:

Fan: [0,100]

Create three linguistic values for each variable.

Write at least nine rules.

Then, for:

T = 32 °C
Humidity = 75%

manually calculate:

fuzzification,
rule firing,
implication,
aggregation,
centroid.

110. Exercise 4 — Sugeno

Convert the same problem to a zero-order Sugeno system.

Let the consequent constants be:

SLOW   = 20
MEDIUM = 50
FAST   = 90

Compare the Mamdani and Sugeno results.

111. Exercise 5 — control

For DC motor speed control, use:

e(k)
Δe(k)

as inputs and:

ΔPWM

as the output.

Define five membership functions:

NB
NS
ZE
PS
PB

Construct the rule table according to your physical sign convention.

Then measure on the step response:

overshoot,
settling time,
steady-state error.

112. Exercise 6 — PID comparison

For the same process, design:

PID,
Mamdani fuzzy control,
fuzzy-tuned PID.

Under the same disturbance, compare:

IAE
ISE
overshoot
settling time

Report the result from measurements rather than assuming that “fuzzy is better.”

113. Exercise 7 — risk model

Inputs:

Budget
Personnel
Schedule pressure

Output:

Project risk

Build a Mamdani system from expert rules.

Then build a Sugeno system using the same data set.

Compare:

interpretability,
error,
computation time,
number of rules.

114. Exercise 8 — FCM

Generate two-dimensional synthetic data.

Apply classical k-means and Fuzzy C-Means.

For samples near cluster boundaries, compare:

k-means label
FCM memberships

115. Exercise 9 — ANFIS

Generate data from a nonlinear function such as:

y = sin(x1) + 0.5*x2²

Tune a Sugeno FIS from the data.

Track training and validation errors separately.

As the number of membership functions increases, examine how the following change:

training error,
validation error,
rule count.

116. Exercise 10 — Type-2

Suppose three experts provide different boundaries for the same temperature term.

For example, the onset of “HOT” may be:

Expert A → 25 °C
Expert B → 27 °C
Expert C → 29 °C

Model this uncertainty with:

one Type-1 membership function,
one Interval Type-2 membership function.

Compare the control outputs of the two systems under sensor noise.

117. Quick reference

When designing a fuzzy system, ask:

1. Is there genuine vagueness in the problem?
2. Am I confusing membership degree with probability?
3. Are the universes of discourse physically correct?
4. Are the linguistic terms meaningful?
5. Do the membership functions cover the entire operating region?
6. Is the overlap sufficient?
7. Is the rule base consistent?
8. Is Mamdani or Sugeno more appropriate?
9. Are the AND/OR/implication/aggregation choices explicit?
10. Is the defuzzification method appropriate?
11. Does the surface agree with physical expectations?
12. Have boundary cases been tested?
13. Have noise and sensor errors been considered?
14. Has performance been measured quantitatively?
15. Are safety limits also enforced outside the FIS on the real system?

118. Conclusion

The essence of fuzzy logic is to use:

graded membership
instead of
a crisp boundary

A real fuzzy system, however, is not merely a mechanism that returns a number between 0 and 1.

The complete engineering chain is:

Conceptual vagueness
↓
Linguistic variable
↓
Membership function
↓
Fuzzification
↓
IF-THEN rules
↓
Inference
↓
Aggregation
↓
Defuzzification
↓
Crisp output
↓
Verification

The historical significance of fuzzy logic is that it made mathematically imprecise concepts computationally tractable.

Its engineering value appears particularly in problems requiring:

expert knowledge,
nonlinear behavior,
smooth transitions,
approximate modeling.

If membership functions and rules are built only from intuition and then used without verification, however, a fuzzy system can appear “human-like” while still being a poor controller.

A sound fuzzy-logic application therefore:

accepts fuzziness in the problem without leaving the design fuzzy.

References

Sources published after the original publication date were used in the September 2026 revision to support technical verification and current tool or standards information.

Foundational works

Zadeh, L. A. “Fuzzy Sets.” Information and Control, 8(3), 338-353, 1965.

DOI: https://doi.org/10.1016/S0019-9958(65)90241-X

Bellman, R. E.; Zadeh, L. A. “Decision-Making in a Fuzzy Environment.” Management Science, 17(4), B141-B164, 1970.

DOI: https://doi.org/10.1287/mnsc.17.4.B141

Zadeh, L. A. “The Concept of a Linguistic Variable and Its Application to Approximate Reasoning—I.” Information Sciences, 8(3), 199-249, 1975.

DOI: https://doi.org/10.1016/0020-0255(75)90036-5

Mamdani, E. H.; Assilian, S. “An Experiment in Linguistic Synthesis with a Fuzzy Logic Controller.” International Journal of Man-Machine Studies, 7(1), 1-13, 1975.

DOI: https://doi.org/10.1016/S0020-7373(75)80002-2

Takagi, T.; Sugeno, M. “Fuzzy Identification of Systems and Its Applications to Modeling and Control.” IEEE Transactions on Systems, Man, and Cybernetics, SMC-15(1), 116-132, 1985.

DOI: https://doi.org/10.1109/TSMC.1985.6313399

Jang, J.-S. R. “ANFIS: Adaptive-Network-Based Fuzzy Inference System.” IEEE Transactions on Systems, Man, and Cybernetics, 23(3), 665-685, 1993.

DOI: https://doi.org/10.1109/21.256541

Dunn, J. C. “A Fuzzy Relative of the ISODATA Process and Its Use in Detecting Compact Well-Separated Clusters.” Journal of Cybernetics, 3(3), 32-57, 1973.

DOI: https://doi.org/10.1080/01969727308546046

Bezdek, J. C.; Ehrlich, R.; Full, W. “FCM: The Fuzzy C-Means Clustering Algorithm.” Computers & Geosciences, 10(2-3), 191-203, 1984.

DOI: https://doi.org/10.1016/0098-3004(84)90020-7

Mendel, J. M.; John, R. I. B. “Type-2 Fuzzy Sets Made Simple.” IEEE Transactions on Fuzzy Systems, 10(2), 117-127, 2002.

DOI: https://doi.org/10.1109/91.995115

Books

Ross, T. J. Fuzzy Logic with Engineering Applications. Wiley.

Klir, G. J.; Yuan, B. Fuzzy Sets and Fuzzy Logic: Theory and Applications. Prentice Hall.

Jang, J.-S. R.; Sun, C.-T.; Mizutani, E. Neuro-Fuzzy and Soft Computing. Prentice Hall.

Zimmermann, H.-J. Fuzzy Set Theory—and Its Applications. Springer.

Current technical documentation

MathWorks. Fuzzy Logic Toolbox Documentation.

https://www.mathworks.com/help/fuzzy/

MathWorks. mamfis — Mamdani fuzzy inference system.

https://www.mathworks.com/help/fuzzy/mamfis.html

MathWorks. evalfis — Evaluate fuzzy inference system.

https://www.mathworks.com/help/fuzzy/mamfis.evalfis.html

MathWorks. mamfistype2 — Interval type-2 Mamdani fuzzy inference system.

https://www.mathworks.com/help/fuzzy/mamfistype2.html

MathWorks. anfis / tunefis migration guidance, R2026a documentation.

https://www.mathworks.com/help/fuzzy/anfis.html

Source course material

Afyon Kocatepe University, Faculty of Technology, Mechatronics Engineering — Fuzzy Logic Control course material, 2019.

The 2019 course material is the historical instructional source for the Mamdani/Sugeno examples, temperature control, traffic lights, multiple-output FIS, and MATLAB-Arduino applications. Software-interface details were separately checked against September 2026 documentation.