Docstoc

Fuzzy logic

Document Sample
Fuzzy logic Powered By Docstoc
					         Fuzzy Logic
Basic Concepts and Applications
1 Introduction

1.1 Why fuzzy control systems ?
Human experience often cannot be described in terms of numeric values. This makes it diffi-
cult to introduce such experience into computer based control systems as these rely on
mathematical algorithms and logic relations using "sharp" numeric or boolean values. Con-
versely there is an urgent need to incorporate human decision making competence into auto-
matic process control systems. Many real world processes are modeled only poorly by
mathematical methods but may very well be controlled by human "common sense". Fuzzy
control uses this intuitive view on real world phenomena and aims at designing automatic
decision making machines by imitating "intuitive" human methods.

Fuzzy control should be used when more formal methods either are not available or are too
complicated for practical applications.

Some well known applications:
Camcorders with sharpness correction
Elevator control with optimized timing
Heating control considering number of persons in a room
Intelligent traffic control systems
Money investment decision making systems
Pattern and speech recognition systems

Fuzzy control systems may be designed using special hardware devices or computers and
software. In both cases the technical requirements are pretty high and large scale applications
have been realized only since some years. Today special fuzzy processors are available in
quantity from stock and new applications are announced on short terms. Many fuzzy systems
use inexpensive personal computers as their hardware platforms.


1.2 History
First paper:
Lofti A. Zadeh: Fuzzy Sets.
Information and Control, 8(1965)
University of Berkeley, Cal.

An outlook:
Ebrahim Mamdami and Seto Assilian, Queen Mary College, London, 1975:
Control of steam engines
In this early phase practical applications did hardly seem possible

A technical breakthrough:
Automatic control of cement production furnace by fuzzy methods. Despite many efforts
process control by conventional methods before had turned out to be impossible. No adequate
process model could be designed.
Copenhagen (Denmark), F. L. Smidth company.



                                              1
Another spectacular application:
Metropolitan subway control in Sendai, Japan

An important German investigation:
Reusch: Potential der Fuzzy-Technologie in Nordrhein-Westfalen.
(Potential of fuzzy technology in the country of Nordrhein-Westfalen.)
Studie der Fuzzy-Initiative NRW, Ministerium für Wirtschaft, Mittelstand und Technologie,
4( 1993)
(Study of the Fuzzy Initiative of NRW, Ministry of Economics and Technology, 4, 1993)




                                               2
2 Entities, Values, Member Function

2.1 Abstract entities, base values, fuzzy values
Abstract entity:
A process variable which is significant in the context of a fuzzy control system is called an
"abstract entity".

Examples:
amount_of_money               significant in financial decision processes
temperature, air_pressure     significant in technical processes
time_of_day, date             significant in real time processes
average_of_marks              significant in education processes
number_of_population          significant in social processes

Abstract entities become concrete by assigning them values in the widest sense

Examples:
The amount_of_money is ...
                big
                small
                1000 dollars
                growing
                not sufficient
The date is ...
                today
                Wednesday morning
                beginning of next week
                January 3rd
The air_pressure
                increases
                remains as it was before
                is extremely low
                is 1023 hPa

Base values
To each abstract entity in a fuzzy control system a basic set of measuring values is assigned.
Which set of base values is chosen in a special application cannot be decided upon in general
but depends on usefulness. Following conditions should be met:

Uniqueness
In any possible situation an abstract entity accepts one and only one of its base values

Measurability
In any possible situation one can determine by measurement the actual momentary base value
of an abstract entity.




                                               3
Examples:
Abstract entity:                      date
Possible set of base values:          B1={ Mon, Tue, Wed, Thur, Fri, Sat, Sun }
Another set of base values:           B2={1.1.96, ... ,31.12.1999 }
Yet another set:                      B3={Jan, Feb, ... ,Dec }
All three sets are numerable

Abstract entity:                      temperature
Possible set of base values:          B1={ t °K; 0.0 ≤ t }
Also possible:                        B2={ t °C; -273.16 ≤ t }
Both sets are continuous

Abstract entity:                      amount_of_money
Possible set of base values:          B1={ x$;    x=positive integer number }
Also possible:                        B2={ x.yy$; x=positive integer number, y=00...99 }
Both sets are numerable

Abstract entity:                      vector
Possible set of base values:          B1={ (x,y,z); x,y,z are real numbers }
Also possible:                        B2={r ,cos(α),cos(β); r=positive real, 0≤ α, β <2π }
Both sets are continuous triples of numbers

Fuzzy values
In colloquial speech abstract entities are often quantified in a different, less formal way. In-
stead of using "sharp" terms from an agreed set of base values "linguistic" terms are em-
ployed. In contrast to its base values an abstract entity may have several linguistic values si-
multaneously and it is not always certain which of its possible linguistic values it possesses at
the moment. Linguistic values are "fuzzy" in some sense. Similar to the base values of an ab-
stract entity also its agreed fuzzy values form a set.

Examples:
Abstract entity:               date
Some linguistic values:        beginning_of_week, later, earlier, end_of_this_year, at_night

Abstract entity:               temperature
Some linguistic values:        hot, warm, cold, much_to_cold, rather_hot

Abstract entity:               amount_of_money
Some linguistic values:        sufficient, small, very_big, poor, insufficient

Abstract entity:               vector
Some linguistic values:        small_by_amount, perpendicular, big_z_component, long

Fuzzy systems rely on the description of relations between abstract entities by means of
linguistic "fuzzy" values.

In contrast, conventional process control systems use sets of base values ("sharp" val-
ues) to describe processes and their time behavior.



                                                4
Just as the base values of an abstract entity also its fuzzy values have to be agreed upon, de-
pending on the considered application and on usefulness in a certain environment. In contrast
to base values fuzzy values must not necessarily be mutually exclusive.

Most important:
Fuzzy values should be words of everyday language or at least be closely related to such
words. So one can describe human experience and human knowledge about a process using
fuzzy values and fuzzy relations between the abstract entities which are characteristic for the
process under consideration.

Examples:
Abstract entity:              date
Possible set of fuzzy values: F1 = { beginning_of_week, mid_of_week, end_of_week }
Another set of fuzzy values: F2 = {spring, summer, autumn, winter }
Yet another set:              F3 = {at_easter, at_whitsun, at_christmas }

Abstract entity:              temperature
Possible set of fuzzy values: F1 = { cold, lukewarm, warm, hot, boiling }
Also possible:                F2 = { low, high }
Also possible:                F3 = { below_zero, about_zero, above_zero }

Abstract entity:              amount_of_money
Possible set of fuzzy values: F1 = { small, medium, sufficient, big }
Also possible:                F2 = { nearly nothing, about_100, about_200, more_than_300 }

Abstract entity:              vector
Possible set of fuzzy values: F1 = { nearly_in_x_direction, nearly_in_y_direction,
                                     nearly_in_z_direction, nearly_perpendicular,
                                     rather_long, rather_short }


2.2   Member function

2.2.1 Definition and meaning
In any possible situation an abstract entity has one and only one sharp value from its agreed
set of base values. In that same situation it has one ore more fuzzy values from its agreed set
of fuzzy values.

Example:
Abstract entity:             date
Set of base values:          B = { Mon, Tue, Wed, Thur, Fri, Sat, Sun }
Set of fuzzy values:         F = { beginning_of_week, mid_of_week, end_of_week }

If entity "date" possesses the sharp value "Wed" (respective Wednesday) this certainly corre-
sponds to the fuzzy value mid_of_week but hardly to beginning_of_week or to end_of_week.




                                              5
One can construct a lookup table:

base does not mean             does perhaps      does probably            does certainly mean
value                          mean              mean
Mon       mid_of_week,                                                    beginning_of_week
          end_of_week
Tue       end_of_week          mid_of_week       beginning_of_week
Wed       beginning_of_week,                                              mid_of_week
          end_of_week
Thur      beginning_of_week,   end_of_week       mid_of_week
Fri       beginning_of_week,   end_of_week       end_of_week
          mid_of_week
Sat       beginning_of_week,                     end_of_week              end_of_week
          mid_of_week
Sun       beginning_of_week,                                              end_of_week
          mid_of_week

Table 1
Above table describes the degree of membership of a sharp base value to one or more of the
fuzzy values of the abstract entity "date". The base value "Thur" does "not" belong to the
fuzzy value "beginning_of_week" , does "perhaps" and also does "probably" belong to
"end_of_week" and does not "certainly" belong to any fuzzy value at all.

This intuitive relation between base and fuzzy values of an abstract entity is expressed more
accurate and quantitatively by the member function, mostly marked with Greek letter µ.

µ(b,f) is a real value function of the two variables b of type "base value" and f of type "fuzzy
value".

Per definition:         0 ≤ µ(b,f) ≤ 1 for any possible choice of b and f

If we have µ(b0,f0)=0 for a certain pair of values (b0,f0) this means that the sharp value b0
does not at all belong to the fuzzy value f0, it is not a "member" of f0. If, conversely, we have
µ(b0,f0)=1 the sharp value b0 belongs completely to the fuzzy value f0. Partial or uncertain
memberships are expressed by function values between 0 and 1.

Example:
Lookup table of µ(b,f) for the above (qualitative) dependency


base value                        fuzzy value                      sum
              beginning_of_week    mid_of_week       end_of_week
Mon                   1.0                0.0              0.0       1.0
Tue                   0.6                0.2              0.0       0.8
Wed                   0.0                1.0              0.0       1.0
Thur                  0.0                0.6              0.3       0.9
Fri                   0.0                0.1              0.7       0.8
Sat                   0.0                0.0              0.9       0.9
Sun                   0.0                0.0              1.0       1.0
Table 2



                                                 6
The sum of the numbers in the horizontal lines is often but not necessary close to 1,0.
More formally:      ∑ µ(b,f) ≈ 1 for any fuzzy value f

A sum of exactly 1 really means that the fuzzy values uniformly cover the whole range of the
base values. In practice the member function is often constructed such that this condition is
met.

For a fixed fuzzy value f=f0 the member function µ(b,f0) is a real valued function of the sin-
gle variable b alone, called partial member function.


2.2.2 Common representations

2.2.2.1 Lookup tables
This kind of representation is used mainly if the sets of base values and fuzzy values both
contain only some few discrete elements.

Example:
Base values:          B = {1, 2, 3, 4, 5, 6 }
Fuzzy values:         F = {unacceptable, acceptable, good, best }

base value                        fuzzy value
                unacceptable acceptable     good          best
      1             0.0            0.0        0.3            1.0
      2             0.0            0.1        0.5            0.2
      3             0.1            0.4        0.2            0.0
      4             0.5            0.3        0.0            0.0
      5             0.8            0.2        0.0            0.0
      6             1.0            0.0        0.0            0.0
Table 3
We read from the table:       µ(3, acceptable) = 0,4        µ(2, optimum) = 0,2


2.2.2.2 Mathematical formula representation
This kind of representation is used mainly if the set of base values is continuous.

Example:
Base values:           B = { x; x=real number, -20 ≤ x ≤+35 }
Fuzzy values:          F = { spring, summer, autumn, winter }
µ(x, spring) = 0,0                    if x<0
               = 0,05*x               if 0≤x≤20
               = 1-0,1*(x-20)         if 20≤x≤30
               = 0,0                  else
µ(x, summer) = 0,0                    if x<10
               = 0,067*(x-10)         if 10≤x≤25
               = 1,0                  if 25≤x
Similarly for µ(x, autumn) and µ(x, winter)


                                               7
2.2.2.3 Computer program representation
General purpose representation for many different applications.

Example:
Base values:         B = { 1, 2, 3, 4, 5, 6 }
Fuzzy values:        F = { unacceptable, acceptable, good, optimum }

// List of fuzzy values
enum fuzzy{ unacceptable, acceptable, good, optimum };

// definition of member function
// b: base value; f: fuzzy value
double mue(short b, fuzzy f)
    { switch(b)
       {
          case 1:
             switch(f)
                 { case unacceptable: return 0.0;
                   case acceptable: return 0.0;
                   case good:                 return 0.3;
                   case optimum:      return 1.0;
                 }
          case 2:
             switch(f)
                 { case unacceptable: return 0.0;
                   case acceptable: return 0.1;
                   case good:                 return 0.5;
                   case optimum:      return 0.3;
                 }
          case 3:
             switch(f)
                 { case unacceptable: return 0.1;
                   case acceptable: return 0.4;
                   case good:                 return 0.2;
                   case optimum:      return 0.0;
                 }
          case 4:
             switch(f)
                 { case unacceptable: return 0.5;
                   case acceptable: return 0.3;
                   case good:                 return 0.0;
                   case optimum:      return 0.0;
                 }
// continued on next page




                                                8
// continuation
         case 5:
             switch(f)
                { case unacceptable: return 0.8;
                   case acceptable: return 0.2;
                   case good:                return 0.0;
                   case optimum:     return 0.0;
                }
         case 6:
             switch(f)
                { case unacceptable: return 1.0;
                   case acceptable: return 0.0;
                   case good:                return 0.0;
                   case optimum:     return 0.0;
                }
         default:        return 0.0;
      }
    }

// Calling program
void main(void)
    { short base_value = 3;
       fuzzy fuzzy_value = good;
       double z;
       z=mue(base_value, fuzzy_value);
    }




                                               9
2.2.2.4 Graphic representation
This kind of representation is mostly used if the set of base values is continuous.
Advantage:            highly descriptive, easy to understand.
Disadvantage:         hardly usable in automatic processing applications

Example:
B = { v; 0 ≤ v ≤ 200 km/h}
F = { stopping, slow, normal, fast, racing }



                          Member function m(b,f)



            1,0

             0,8

             0,6
 m(b,f)
             0,4

              0,2

              0,0
                    0        40        80           120      160        200
                        Speed in km/h
            stopping         slow              normal
            fast             racing


Picture 1




                                               10
2.3 Fuzzy numbers
Often abstract entities are on one hand described by sharp numbers as their base values, on the
other hand by fuzzy values like "about_1", "about_2.5", "roughly_6.0". The latter terms are
called "fuzzy" because they are in some way "unsharp". The corresponding member functions
are most often chosen as Gaussian distributions (especially where measuring problems are
encountered) or as triangular functions.

Example:
Abstract entity:             temperature/˚K
Set of base values   :       B = { t;         t=positive real number }
Set of fuzzy values:         F = { about_T; T=positive real number }
Both sets are innumerable, set B is also continuous, for set F continuity is not defined.

Member function (Gauss): µ(t, about_T) = exp[ -a*(t-T)² ]            a > 0, constant
Member function (Triangle): µ(t, about_T) = 0          if t ≤ T-a    a > 0, constant
                                          = (t-T+a)/a if T-a ≤ t ≤ T
                                          = (t-T+b)/a if T ≤ t ≤ T+b b > 0, constant
                                          =0           if t ≥ T+b

Here you see how both member functions look like for a=b=1



                                Member function m(b,about_0)


                   1
                  0,8
                  0,6
         m(b,f)




                  0,4
                  0,2
                   0
                        -1,8 -1,4   -1   -0,6 -0,2    0      0,6     1   1,4   1,8
                                            Base values b

                                            Gauss         triangle

Picture 2




                                                 11
2.4 Fuzzy intervals / Fuzzy flat numbers
Consider an abstract entity with base values which are ordinary real numbers and fuzzy values
similar to the following:

roughly_between_1_and_5
approximately_in_the_range_from_100_to_120
probably_between_ 5_and_6

Fuzzy values of that kind are called "fuzzy flat numbers" or "fuzzy intervals". The member
function is usually chosen to be of trapezoidal shape.

Example:
Abstract entity:              temperature
Set of base values:           B = { t; t=positive real number }
Set of fuzzy values:          F = { seemingly_below_(-10),
                                      approximately_in_(-10 to 0),
                                      approximately_in_(0 to +10),
                                      approximately_in_(+10 to +20),
                                      seemingly_above_(+20)
                                   }

Trapezoidal member function:
µ(t, seemingly_below_(-10) ) = 1                     if t ≤ -15
                             = 1-(t+15)/10           if -15 ≤ t≤ -5
                             =0                      if -5 ≤ t
                             ( trapezoid, left side open )

µ(t, approximately_in(-10 to 0) ) = 1               if t ≤ -12
                                 = (t+12)/4         if -12 ≤ t ≤ -8
                                 =1                 if -8 ≤ t ≤ -2
                                 = 1-(t+2)/5        if -2 ≤ t ≤ +3
                                 =0                 if +3 ≤ t
                                 ( trapezoid with different inclinations on both sides )
Similar:
µ(t, approximately_in(0 to +10) ) = ....
µ(t, approximately_in(+10 to +20) ) = ....
µ(t, approximately_in(0 to +10) ) = ....
µ(t, seemingly_above_(+20) )          = ....


2.5 Fuzzy sets
Consider an abstract entity with agreed sets B={b} of base values and F={f} of fuzzy values.
To each fuzzy value f from F a new set M(f) may be attached which is defined as follows:

M(f) = { [b, µ(b,f)]; b ∈ B }




                                               12
Colloquially:
M(f) consists of all base values b ∈ B of the abstract entity, each value b being "paired" with
its degree of membership to the fuzzy value f under consideration. M(f) is called "fuzzy set of
fuzzy value f over base value set B " or simply "fuzzy set of f over B" or even more simple
"fuzzy set of f".

Example:
Lookup table of µ(b,f)


base value                        fuzzy value                     sum
             beginning_of_week     mid_of_week      end_of_week
Mon                  1.0                 0.0             0.0       1.0
Tue                  0.6                 0.2             0.0       0.8
Wed                  0.0                 1.0             0.0       1.0
Thur                 0.0                 0.6             0.3       0.9
Fri                  0.0                 0.1             0.7       0.8
Sat                  0.0                 0.0             0.9       0.9
Sun                  0.0                 0.0             1.0       1.0

Table 4
From that the following three fuzzy sets are derived:

M(beginning_of_week) =
      {(Mon,1.0), (Tue, 0.6), (Wed,0.0), (Thur,0.0), (Fri, 0.0), (Sat,0.0), (Sun,0.0) }
M(mid_of_week) =
      {(Mon,0.0), (Tue, 0.2), (Wed,1.0), (Thur,0.6), (Fri, 0.1), (Sat,0.0), (Sun,0.0) }
M(end_of_week) =
      {(Mon,0.0), (Tue, 0.0), (Wed,0.0), (Thur,0.3), (Fri, 0.7), (Sat,0.9), (Sun,1.0) }

In principle each fuzzy set contains all agreed base values b with their respective degrees of
membership to the fuzzy value f0 under consideration. But rather often base values with
µ(b,f0)=0 are omitted. Usual reasoning: "they do not belong to the considered fuzzy value" or,
alternatively, "they are not contained in the fuzzy set".


2.6 Generalized fuzzy sets
All fuzzy sets are of the general form

M = { (b, m); b in some set of base values, 0.0≤m≤1.0 }

A certain pair (b, m) is contained only once in set M, that means the elements of M are differ-
ent by pairs. Besides no two pairs (b1,m1) and (b2,m2) do exist with b1=b2 but m1≠m2. Each
element b therefor has a unique attached membership m.

The following definitions are useful:

Unity set:      E = { (b,1);     b in set of base values }
Zero set:       Z = { (b,0);     b in set of base values }


                                                  13
Subset:
Set
         M1 = { (b,m1); b in set of base values, 0≤m1≤1 }
is a subset of set
         M2 = { (b,m2); b in set of base values, 0≤m2≤1 }
if for each value of b holds
         m1≤ m2

True subset of a set:
Set
         M1 = { (b,m1); b in set of base values, 0≤m1≤1 }
is a true subset of set
         M2 = { (b,m2); b in set of base values, 0≤m2≤1 }
if for each value of b holds
         m1 ≤ m2
and for at least one value of b really
         m 1 < m2

Equality of sets:
 Sets
         M1 = { (b,m1); b in set of base values, 0≤m1≤1 }
and
         M2 = { (b,m2); b in set of base values, 0≤m2≤1 }
are equal
if for each value of b holds
         m 1 = m2

Each fuzzy set over base value set B is contained in the unity set over B, that means is a sub-
set of the unity set over B.

Each fuzzy set over base value set B contains the zero set over B, that means the zero set is a
subset B.




                                               14
3 Operations with fuzzy sets

3.1 Complement set / NOT
Conventional set theory definition
Given a set M of elements from a base value set B the complementary set ⌐M is defined to be
the set of those elements from B which do not belong to set M: ⌐M={ b; b∈B, b∉M }

Fuzzy set theory definition
Given a fuzzy set M = { [b,m]; b ∈ B, 0 ≤ m ≤ 1 } over a base value set B the complementary
fuzzy set ⌐M is defined as ⌐M = { [b,(1-m)] }

Example:
 M = { (Mon, 0.2), (Tue, 0.5), (Wed, 0.4), (Thur, 0.0), (Fri, 1.0), (Sat, 0.3), (Sun, 1.0) }
⌐M = { (Mon, 0.8), (Tue, 0.5), (Wed, 0.6), (Thur, 1.0), (Fri, 0.0), (Sat, 0.7), (Sun, 0.0) }

A certain value b0 which is completely contained in M is not at all contained in ⌐M
m(b0) = 1      →      1- m(b0) = 0
A certain value b0 which is partially contained in M is also partially contained in ⌐M
0 < m(b0) < 1 →       0 < 1- m(b0) < 1
A certain value b0 which is not at all contained in M is completely contained in ⌐M
m(b0) = 0      →      1- m(b0) = 1

What is that good for ? The prefix NOT
Starting from a given set F = { f } of fuzzy values of an abstract entity A it often proves use-
ful to add new colloquial terms to F, that is to add new fuzzy values. We begin with negation.

Each fuzzy value f from F is prefixed by the term NOT_ so that we get the new terms
NOT_f. These are considered to be new additional fuzzy values of abstract entity A and are
adjoined to the original set F.

Accordingly the membership function of abstract entity A is redefined:

µ(b,NOT_f) = 1- µ(b,f)          for all new fuzzy values NOT_f of A

The respective fuzzy sets are

M(NOT_f) = { [b,µ(b,NOT_f)] } = { [ b, ( 1-µ(b,f) ) ] } = ⌐M(f)


In words:
The fuzzy set belonging to the fuzzy value NOT_f is the complement of the fuzzy set be-
longing to f.

Example:
Abstract entity:                date
Set of base values:             B = { Mon, Tue, Wed, Thur, Fri, Sat, Sun }



                                                15
Original set of fuzzy values:
F = { beginning_of_week, mid_of_week, end_of_week }

Enlarged set of fuzzy values:
F = { beginning_of_week, mid_of_week, end_of_week,
      NOT_beginning_of_week, NOT_mid_of_week, NOT_end_of_week }

Original fuzzy sets:
M(beginning_of_week) =
       {(Mon, 1.0), (Tue, 0.6), (Wed, 0.0), (Thur, 0.0), (Fri, 0.0), (Sat, 0.0), (Sun, 0.0) }
M(mid_of_week) =
       {(Mon, 0.0), (Tue, 0.2), (Wed, 1.0), (Thur, 0.6), (Fri, 0.1), (Sat, 0.0), (Sun, 0.0) }
M(end_of_week) =
       {(Mon, 0.0), (Tue, 0.0), (Wed, 0.0), (Thur, 0.3), (Fri, 0.7), (Sat, 0.9), (Sun, 1.0) }

Additional fuzzy sets:
M(NOT_beginning_of_week) =
       { (Mon, 0.0), (Tue, 0.4), (Wed, 1.0), (Thur, 1.0), (Fri, 1.0), (Sat, 1.0), (Sun, 1.0) }
M(NOT_mid_of_week) =
       { (Mon, 1.0), (Tue, 0.8), (Wed, 0.0), (Thur, 0.4), (Fri, 0.9), (Sat, 1.0), (Sun, 1.0) }
M(NOT_end_of_week) =
       { (Mon, 1.0), (Tue, 1.0), (Wed, 1.0), (Thur, 0.7), (Fri, 0.3), (Sat,0.1), (Sun,0.0) }

Instead of prefix NOT_ other prefixes with similar meanings may be used if required.


3.2 Intersection / AND
Conventional set theory definition
Given two sets M1 and M2 of elements from a base set B the intersection set M= M1∩ M2 is
defined to be the set of exactly those elements from B which belong to both sets M1 and M2
simultaneously:        M = M1∩ M2 = { b; b both in M1 and M2}

Fuzzy set theory definition
Given two fuzzy sets
M1 = { [b,m1]; b ∈ B, 0 ≤ m1 ≤ 1 } and M2 = { [b,m2]; b ∈ B , 0 ≤m2 ≤1 }
over a base value set B
the intersection set is defined as M = M1∩ M2 = { [b,min(m1,m2)] }

Example:
M1       = { (Mon,1.0), (Tue, 0.6), (Wed, 0.4), (Thur, 0.2), (Fri, 0.0), (Sat, 0.8), (Sun, 0.0) }
M2       = { (Mon, 0.7), (Tue, 0.2), (Wed, 1.0), (Thur, 0.6), (Fri, 0.1), (Sat, 0.0), (Sun, 0.0) }
M1∩ M2 = { (Mon, 0.7), (Tue, 0.2), (Wed, 0.4), (Thur, 0.2), (Fri, 0.0), (Sat, 0.0), (Sun, 0.0) }

A certain value b0 which is completely contained in both M1 and M2 is also completely con-
tained in M1∩ M2:       m1(b0) =1 and m2(b0)=1 → min(m1,m2) = 1


                                                16
A certain value b0 which is only partially contained in M1 or in M2 is also only partially con-
tained in M1∩ M2:     0 < m1(b0) < 1 or 0 < m2(b0) < 1 → 0 < min(m1,m2) < 1

A certain value b0 which is not at all contained in M1 or in M2 is also not at all contained in
M1∩ M2:                       m1(b0)=0 or m2(b0)=0 → min(m1,m2) = 0

What is that good for ? The infix AND
As before we start with a given set F = { f } of fuzzy values of an abstract entity A and add
new colloquial terms to it, this time using the connecting term "and".

To do so any two fuzzy values f1 and f2 from F are connected by the infix _AND_ . By that
we get the new terms f1_AND_f2 which are considered to be new additional fuzzy values of
abstract entity A. They are adjoined to the original set F of fuzzy values.

The membership function of abstract entity A is redefined:

µ(b,f1_AND_f2) = min[µ(b,f1), µ(b,f2) ]      for all new fuzzy values f1_AND_f2 of A

Respective fuzzy sets are

M(f1_AND_f2) = { [b, µ(b,f1_AND_f2)] } = { ( b,min[µ(b,f1), µ(b,f2) ]) } = M(f1) ∩ M(f1)

In words:
The fuzzy set belonging to the fuzzy value f1_AND_f2 is the fuzzy intersection set of the
fuzzy sets belonging to f1 and to f2.

Example:
Abstract entity:              date
Set of base values:           B = { Mon, Tue, Wed, Thur, Fri, Sat, Sun }

Original set of fuzzy values:
F = { beginning_of_week, mid_of_week, end_of_week }

Enlarged set of fuzzy values:
F = { beginning_of_week, mid_of_week, end_of_week,
      beginning_of_week_AND_mid_of_week, beginning_of_week_AND_end_of_week,
      mid_of_week_AND_end_of_week }

As infix _AND_ is symmetric, that means as µ(b,f1_AND_f2)=µ(b,f2_AND_f1), other possible
fuzzy values like "mid_of_week_AND_beginning_of_week" need not be considered.

"mid_of_week_AND_beginning_of_week" is similar to
"begining_of_week_AND_mid_of_week".




                                               17
Original fuzzy sets:
M(beginning_of_week) =
       {(Mon,1.0), (Tue, 0.6), (Wed, 0.0), (Thur, 0.0), (Fri, 0.0), (Sat, 0.0), (Sun, 0.0) }
M(mid_of_week) =
       {(Mon, 0.0), (Tue, 0.2), (Wed, 1.0), (Thur, 0.6), (Fri, 0.1), (Sat, 0.0), (Sun, 0.0) }
M(end_of_week) =
       {(Mon, 0.0), (Tue, 0.0), (Wed, 0.0), (Thur, 0.3), (Fri, 0.7), (Sat, 0.9), (Sun,1.0) }


Additional fuzzy sets:
M(beginning_of_week_AND_mid_of_week) =
M(beginning_of_week) ∩ M(mid_of_week) =
      { (Mon, 0.0), (Tue, 0.2), (Wed, 0.0), (Thur, 0.0), (Fri, 0.0), (Sat, 0.0), (Sun, 0.0) }

M(beginning_of_week_AND_end_of_week) =
M(beginning_of_week) ∩ M(end_of_week) =
      { (Mon, 0.0), (Tue, 0.0), (Wed, 0.0), (Thur, 0.0), (Fri, 0.0), (Sat, 0.0), (Sun, 0.0) }

M(mid_of_week_AND_end_of_week) =
M(mid_of_week) ∩ M(end_of_week) =
     { (Mon, 0.0), (Tue, 0.0), (Wed, 0.0), (Thur, 0.3), (Fri, 0.1), (Sat, 0.0), (Sun, 0.0) }

Instead of infix _AND_ other infixes with similar meaning may be used if required.


3.3 Junction / OR
Conventional set theory definition
Given two sets M1 and M2 of elements from a base set B the junction set M= M1∪ M2 is de-
fined to be the set of exactly those elements from B which either belong to set M1 or to set M2
or to both sets simultaneously:

M = M1∪ M2 = { b; b ∈ M1 or b ∈ M2 }

Fuzzy set theory definition
Given two fuzzy sets M1={ [b,m1]; b in B, 0 ≤ m1 ≤ 1 } and M2 = { [b,m2]; b in B, 0 ≤ m2 ≤1 }
over a base value set B the junction set M= M1∪ M2 is defined as M = { [ b , max(m1,m2) ] }


Example:
M1       = { (Mon, 1.0), (Tue, 0.6), (Wed, 0.4), (Thur, 0.2), (Fri, 0.0), (Sat, 0.8), (Sun, 0.0) }
M2       = { (Mon, 0.7), (Tue, 0.2), (Wed, 1.0), (Thur, 0.6), (Fri, 0.1), (Sat, 0.0), (Sun, 0.0) }
M1∪ M2 = { (Mon, 1.0), (Tue, 0.6), (Wed, 1.0), (Thur, 0.6), (Fri, 0.1), (Sat, 0.8), (Sun, 0.0) }

A certain value b0 which is completely contained in at least one of the sets M1 or M2 is also
completely contained in M1∪ M2:       m1(b0) = 1 or m2(b0) = 1 → max(m1,m2) = 1



                                                18
A certain value b0 which is at least partially contained in M1 or in M2 is always at least par-
tially contained in M1∪ M2: 0 < m1(b0) or 0 < m2(b0) → 0 < max(m1,m2)

A certain value b0 which is neither contained in M1 nor in M2 also not at all is contained in
M1 ∪ M2:                               m1(b0) = 0 and m2(b0) = 0 → max(m1,m2) = 0

What is that good for ? The infix OR
This time we start with a given set F = { f } of fuzzy values of an abstract entity A and add
new colloquial terms to it using the connecting term "or".

Any two fuzzy values f1 and f2 from F are connected by the infix _OR_ which results in the
new terms f1_OR_f2 . They are adjoined as new fuzzy values to the original set F.

The membership function of abstract entity A is redefined:

µ(b,f1_OR_f2) = max [ µ(b,f1), µ(b,f2) ]      for all new fuzzy values f1_OR_f2 of A

The respective fuzzy sets are

M(f1_OR_f2) = { [b, µ(b,f1_OR_f2)] } = { ( b,max[µ(b,f1), µ(b,f2) ]) } = M(f1) ∪ M(f1)

In words:
The fuzzy set belonging to the fuzzy value f1_OR_f2 is the fuzzy junction set of the fuzzy sets
belonging to f1 and to f2.

Example:
Abstract entity:                date
Set of base values:             B = { Mon, Tue, Wed, Thur, Fri, Sat, Sun }

Original set of fuzzy values:
F = { beginning_of_week, mid_of_week, end_of_week }

Enlarged set of fuzzy values:
F = { beginning_of_week, mid_of_week, end_of_week,
      beginning_of_week_OR_mid_of_week, beginning_of_week_OR_end_of_week,
      mid_of_week_OR_end_of_week }

As infix _OR_ is symmetric, that means as µ(b,f1_OR_f2)=µ(b,f2_OR_f1), other possible
fuzzy values like "mid_of_week_OR_beginning_of_week" need not be considered.

"mid_of_week_OR_beginning_of_week" is similar to
"beginning_of_week_OR_mid_of_week".




                                               19
Original fuzzy sets:
M(beginning_of_week) =
       {(Mon, 1.0), (Tue, 0.6), (Wed, 0.0), (Thur, 0.0), (Fri, 0.0), (Sat, 0.0), (Sun, 0.0) }
M(mid_of_week) =
       {(Mon, 0.0), (Tue, 0.2), (Wed, 1.0), (Thur, 0.6), (Fri, 0.1), (Sat, 0.0), (Sun, 0.0) }
M(end_of_week) =
       {(Mon, 0.0), (Tue, 0.0), (Wed, 0.0), (Thur, 0.3), (Fri, 0.7), (Sat,0.9), (Sun,1.0) }

Additional fuzzy sets:
M(beginning_of_week_OR_mid_of_week) =
M(beginning_of_week) ∪ M(mid_of_week) =
      { (Mon,1.0), (Tue, 0.6), (Wed, 1.0), (Thur, 0.6), (Fri, 0.1), (Sat, 0.0), (Sun, 0.0) }

M(beginning_of_week_OR_end_of_week) =
M(beginning_of_week) ∪ M(end_of_week) =
      { (Mon, 1.0), (Tue, 0.6), (Wed, 0.0), (Thur, 0.3), (Fri, 0.7), (Sat, 0.9), (Sun, 1.0) }

M(mid_of_week_OR_end_of_week) =
M(mid_of_week) ∪ M(end_of_week) =
     { (Mon, 0.0), (Tue, 0.2), (Wed, 1.0), (Thur, 0.6), (Fri, 0.7), (Sat, 0.9), (Sun,1.0) }

Instead of infix _OR_ other infixes with similar meaning may be used if required.


3.4 More general definitions
Above we defined the operations of intersection and junction of two fuzzy sets as follows:

Intersection:   M1∩ M2 = { [b,min(m1,m2)] }
Junction:       M1∪ M2 = { [b,max(m1,m2)] }

Similarly we defined "derived" fuzzy values from original ones by the infixes

_AND_:          µ(b,f1_AND_f2) = min[µ(b,f1), µ(b,f2) ]
_OR_:           µ(b,f1_OR_f2) = max[µ(b,f1), µ(b,f2) ]

In fact, these definitions are only special cases of more general ones using so-called "T-Norm
functions" and "S-Norm functions". These expressions mean real-valued functions with spe-
cial properties which will be discussed later in detail.

Here are the two most important properties of T-Norm functions T(x,y) and S-Norm functions
S(x,y):

T(x,y) and S(x,y) are functions of two real variables x and y defined in the argument ranges
0≤x≤1 and 0≤y≤1, respectively




                                                20
The function values of T(x,y) and S(x,y) also are in the ranges 0≤T(x,y)≤1 and 0≤S(x,y)≤1,
respectively

Using any T-Norm T(x,y) and S-Norm S(x,y) we can now generalize definitions of fuzzy set
operations:
Intersection:     M1∩ M2 = { [b, T(m1,m2)] }
Junction:       M1∪ M2 = { [b, S(m1,m2)] }
_AND_:          µ(b,f1_AND_f2) = T( µ(b,f1), µ(b,f2) )
_OR_:           µ(b,f1_OR_f2) = S( µ(b,f1), µ(b,f2) )

As will be seen later for 0≤x≤1 and 0≤y≤1 min(x,y) is a T-Norm function and max(x,y) an S-
Norm function Following two tables list some well-known T- and S-Norms.

Function definition: T(x,y) =         Function name
0             if max(x,y) < 1         Drastic product
min(x,y)      if max(x,y) = 1
max(0,x+y-1)                          Limited difference
x*y/[1+(1-x)*(1-y)]                   Einstein product
x*y                                   Algebraic product
x*y/[1-(1-x)*1-y)]                    Hamacher product
min(x,y)                              Minimum
Table 5 Some T-Norm functions

Function definition: S(x,y) =         Function name
max(x,y)                              Maximum
1-(1-x)*(1-y)/(1-x*y)                 Hamacher sum
1-(1-x)*(1-y)                         Algebraic sum
1-(1-x)*(1-y)/(1+x*y)                 Einstein sum
min(1,x+y)                            Limited sum
1              if min(x,y) > 0        Drastic sum
max(x,y)       if min(x,y) = 0
Table 6 Some S-Norm functions

3.5 Common properties of T-Norm functions and S-Norm functions
The above T-Norm and S-Norm functions have common properties which are listed here for
reference. Proofs have been omitted but are given in the appendix.

Range of definition:
0≤x≤1                                 0≤y≤1

Range of values:
0 ≤ T(x,y) ≤ 1                        0 ≤ S(x,y) ≤ 1

Commutivity
T(x,y) = T(y,x)                      S(x,y) = S(x,y)


                                               21
Associativity
T[ T(x,y),z ] = T[ x,T(y,z) ]        S[ S(x,y),z ] = S[ x,S(y,z) ]

Monotony
From x ≤ u and y ≤ v always follows
T(x,y) ≤ T(u,v)                     S(x,y) ≤ S(u,v)

Special values
T(0,y) = 0                           S(0,y) = y
T(1,y) = y                           S(1,y) = 1


The above equations serve as definitions:
Each function with properties in the left column is called a T-Norm function or Triangular
Norm function, each function with properties in the right column an S-Norm function or Tri-
angular Conorm function.

Generalized De-Morgan relations
Consider the following six pairs of T-Norms and S-Norms:

T-Norm: T(x,y)             S-Norm: S(x,y)
drastic product(x,y)       drastic sum(x,y)
limited difference(x,y)    limited sum(x,y)
Einstein product(x,y)      Einstein sum(x,y)
algebraic product(x,y)     algebraic sum(x,y)
Hamacher product(x,y)      Hamacher sum(x,y)
minimum(x.y                maximum(x,y)
Table 7 Pairs of Norm and Conorm functions
For each of these pairs the following equations are valid:
T(x,y) = 1 - S(1-x, 1-y)             S(x,y) = 1 - T(1-x, 1-y)

Each pair of Triangular Norm and Conorm functions which obey the generalized De-Morgan
relations is called a pair of "related" Triangular Norm functions. All membership functions
both for AND - and OR - connections of fuzzy values treated so far are pairs of related Tri-
angular Norms and Conorms. The T-Norm functions hold for the AND-connection, the
S-Norm functions for the OR-connection.

Why do we call these functions "triangular" ?

Because of T(x,y) = T(y,x) and S(x,y) = S(y,x) both functions have do be defined only in the
triangular area 0 ≤ x ≤ 1, 0 ≤ y ≤ x




                                              22
Ascending sequence of function values

For any given values of x and y the following ascending sequence of function values is valid:

0 ≤   drastic product(x,y)     ≤   limited difference(x,y)   ≤    Einstein product(x,y)
  ≤   algebraic product(x,y)   ≤   Hamacher product(x,y)     ≤    minimum(x,y)
  ≤   maximum(x,y)             ≤   Hamacher sum              ≤    algebraic sum
  ≤   Einstein sum             ≤   limited sum               ≤    drastic sum
  ≤   1

For any two T-Norm and S-Norm functions (not only for related ones) the following ine-
qualities are valid:

0 ≤ T(x,y) ≤ T(1,y) ≤ y ≤ S(0,y) ≤ S(x,y) ≤ 1

An important additional inequality
For any pair x,y between 0 and 1, inclusively, there is
1 - x - y + x*y = 1 - x*(1-y) - y ≥ 1 -1* (1-y) - y = 1 - (1-y) - y = 0
or
x + y - x*y ≤ 1

More exactly:
If max(x,y) = 1        then    x + y - x*y = 1
If max(x,y) < 1        then    x + y - x*y < 1


3.6 Additional formula
As the associativity rule is valid for all Norm and Conorm functions the following general-
ized definitions make sense

T(x,y,z) = T(T(x,y),z) = T(x,T(y,z))           S(x,y,z) = S(S(x,y),z) = S(x,S(y,z))

or for N parameters

T(x1,x2,...,xN) = T(T (x1,x2,...,xN-1),xN) = T(x1,T(x2,...,xN))
S(x1,x2,...,xN) = S(S (x1,x2,...,xN-1),xN) = S(x1,S(x2,...,xN))

Limited difference / Limited sum
T(x1,x2,...,xN) = max [0, ∑xn - (N-1) ]        S(x1,x2,...,xN) = min [1, ∑xn ]

Algebraic product / Algebraic sum
T(x1,x2,...,xN) = ∏xn                          S(x1,x2,...,xN) = 1 - ∏(1-xn)

Minimum / Maximum
T(x1,x2,...,xN) = min(x1,x2,...,xN)            S(x1,x2,...,xN) = max(x1,x2,...,xN)

For other triangular functions no simple generalization formula do exist



                                                 23
3.7 Numeric example
Suppose x=0.6 and y=0.2.

Drastic product
T(0.6, 0.2) = 0               as max (x,y) = max (0.6,0.2) = 0.6 < 1

Limited difference
T(0.6, 0.2) = max (0,x+y-1) = max (0, -0.2) = 0

Einstein product
T(0.6, 0.2) = x*y / [1+(1-x)*(1-y)] = 0.6*0.2 / (1+0.4*0.8) = 0.12 / 1.32 = 0.091

Algebraic product
T(0.6, 0.2) = x*y = 0.6*0.2 = 0.12

Hamacher product
T(0.6, 0.2) = x*y / [1-(1-x)*1-y)] = 0.6*0.2 / (1-0.4*0.8) = 0.12 / 0.68 = 0.176

Minimum
T(0.6, 0.2) = min (x,y) = min (0.6, 0.2) = 0.2

Maximum
S(0.6, 0.2) = max (x,y) = max (0.6, 0.2) = 0.6

Hamacher sum
(0.6, 0.2) = 1-(1-x)*(1-y) / (1-x*y) = 1- 0.4*0.8 / (1-0.6*0.2) = 1 - 0.32 / 0.88 = 0.636

Algebraic sum
S(0.6, 0.2) = 1-(1-0.6)*(1-0.2) = 1- 0.4*0.8 = 1 - 0.32 = 0.68

Einstein sum
S(0.6, 0.2) = 1-(1-x)*(1-y) / (1+x*y) = 1- 0.4*0.8 / (1+ 0.6*0.2) = 1 - 0.32 / 1.12 = 0.714

Limited sum
S(0.6, 0.2) = min (1,x+y) = min (1, 0.6+0.2) = min (1,0.8) = 0.8

Drastic sum
S(0.6, 0.2) = 1               as min (x,y) = min (0.6,0.2) = 0.2 > 0

The sequence of ascending numeric values is clearly seen.




                                                 24
3.8   Connecting a fuzzy set to itself

3.8.1 Intersection
In contrast to traditional set theory the intersection of fuzzy set M = { (b,m) } with itself is
not necessary equal to M.

M∩ M = { [b, T(m,m)] } ≠ M if T(m,m) ≠ m              (which is normally the case).

Depending on the choice of T(x,y) the following table gives respective memberships T(m,m)
of base values b in fuzzy set M∩ M.

Function name        Function definition: T(x,y) =         T(m,m) =
Drastic product      0             if max(x,y) < 1         0 if m < 1
                     min (x,y)     if max(x,y) = 1         1 if m = 1
Limited differ-      max (0,x+y-1)                         0        if m ≤ 0.5
ence                                                       2*m -1 if m > 0.5
Einstein product     x*y / [1+(1-x)*(1-y)]                 m² / (2-2*m+ m²)
Algebraic product    x*y                                   m²
Hamacher prod-       x*y / [1-(1-x)*1-y)]                  m / (2-m)
uct
Minimum              min (x,y)                             m
Table 8 Membership functions of fuzzy set intersection with itself

For all T-Norms in the table there is T(m,m) ≤ min(m,m) = m and therefore M ∩ M =
{ [b, T(m,m)] } is a subset of M. With exception of T(x,y)=min(x,y) M∩ M even is a true
subset of M as one easily can prove that at least one value of m exists for which is definitely
T(m,m) < m. If T(x,y)=min(x,y) then T(m,m) = m so that M and M∩ M are identical.




                                                25
3.8.2 Junction
Also the junction of fuzzy set M ={ (b,m) } with itself is          not necessary equal to M.

M ∪ M = { [b, S(m,m)] } ≠ M if S(m,m) ≠ m (which is normally the case).

Depending upon the choice of S(x,y) the following table gives respective memberships
S(m,m) of base values b in fuzzy set M∪M.

Function name       Function definition: S(x,y) =        S(m,m) =
Maximum             max(x,y)                             m
Hamacher sum        1-(1-x)*(1-y) / (1-x*y)              2*m / (1+m)
Algebraic sum       1-(1-x)*(1-y)                        m*(2-m)
Einstein sum        1-(1-x)*(1-y) / (1+x*y)              2*m / (1+m²)
Limited sum         min (1,x+y)                          2*m if m ≤ 0.5
                                                         1      if m > 0.5
Drastic sum         1              if min (x,y) > 0      1      if m > 0
                    max (x,y)      if min (x,y) = 0      0      if m = 0
Table 9 Membership functions of fuzzy set junction with itself

For all S-Norms in the table there is S(m,m) ≥ max(m,m) = m and therefore M ∪ M =
{ [b, S(m,m)] } is a superset of M. With exception of S(x,y)=max(x,y) M∪M even is a true
superset of M as one easily can prove that at least one value m exists for which definitely is
S(m,m) > m. If S(x,y)=max(x,y) then S(m,m) = m which means that M and M∪M are iden-
tical.


3.9   Connecting a fuzzy set to its complement set

3.9.1 Intersection
Different to traditional set theory the intersection of fuzzy set M = { (b,m) } with its comple-
ment set ⌐M = { (b,1-m) } is not necessary an empty set

M∩ (⌐M) = { [b, T(m,1-m)] } ≠ ∅ if T(m,1-m) ≠ 0

The following table gives respective memberships of base values b in fuzzy set M ∩ (⌐M) .
Only the "drastic product" and the "limited difference" functions result in M∩ (⌐M) = ∅ as
traditionally expected, the other T-Norm functions do not




                                               26
Function name           Function definition: T(x,y) =       T(m,m) =
Drastic product         0              if max(x,y) < 1      0
                        min (x,y)      if max(x,y) = 1
Limited difference      max (0,x+y-1)                       0
Einstein product        x*y / [1+(1-x)*(1-y)]               m*(1-m) / [1+(1-m)*m]
Algebraic product       x*y                                 m*(1-m)
Hamacher product        x*y / [1-(1-x)*1-y)]                m *(1-m) / [1-(1-m)*m]
Minimum                 min (x,y)                           min (m,1-m)
Table 10 Membership functions of fuzzy set intersection with complement set

3.9.2 Junction
The junction of fuzzy set M = { (b,m) } with its complement set ⌐M = { (b,1-m) } is not nec-
essary the unity set

M∪ (⌐M) = { [b, S(m,1-m)] } ≠ 1 if S(m,1-m) ≠ 1.

The following table gives respective memberships of base values b in fuzzy set M∪(⌐M).
Only the "limited sum" and the "drastic sum" functions result in M∪(⌐M) = 1 as traditionally
expected, the other S-Norm functions do not

Function name        Function definition: S(x,y) =       S(m,m) =
Maximum              max(x,y)                            max(m, 1-m)
Hamacher sum         1-(1-x)*(1-y) / (1-x*y)             [1-2*m*(1-m)] / [ (1-m*(1-m)]
Algebraic sum        1-(1-x)*(1-y)                       1 - m*(1-m)
Einstein sum         1-(1-x)*(1-y) / (1+x*y)             1 / [1+m*(1-m)]
Limited sum          min(1,x+y)                          1
Drastic sum          1              if min(x,y) > 0      1
                     max(x,y)       if min(x,y) = 0
Table 11 Membership functions of fuzzy set junction complement set

3.10 Scalable triangular functions
With any pair of related Norm and Conorm functions a "weighted average" may be formed:

R(x,y) = (1-α)*T(x,y) + α*S(x,y)            arithmetic average, 0 ≤ α ≤ 1

R(x,y) = T(x,y) (1-α) + S(x,y) α            geometric average, 0 ≤ α ≤ 1

Many scalable functions are discussed in literature, some of which are given here:

Hamacher intersection function
P(x,y) = x*y / [α - (α - 1)*(x+y-x*y)]                     0≤α≤∞




                                              27
For special selections of parameter α this goes over into the following T-Norm functions:
α = 0: Hamacher product
α = 1: Algebraic product
α = 2: Einstein product
α = ∞: Drastic product

Hamacher junction function
Q(x,y) = [ (α - 1)*x*y + x + y ] / (1 + x*y)        -1 ≤ α ≤ ∞

For special selections of parameter α this goes over into the following S-Norm functions:
α = -1: Hamacher sum
α = 0: Algebraic sum
α = 1: Einstein sum
α = ∞: Drastic sum

Yager intersection function

P(x, y) = 1 − min[1,α (1 − x)α + (1 − y )α ]

For special selections of parameter α this goes over into the following T-Norm functions:
α = 1: Limited difference
α = ∞: Minimum

Yager junction function

Q(x, y) = min[1,α xα + yα ]

For special selections of parameter α this goes over into the following S-Norm functions:
α = 1: Limited sum
α = ∞: Maximum

Werner functions
P(x,y) = α*min(x,y) + (1- α )*(x+y)/2               AND-connecting function
Q(x,y) = α*max(x,y) + (1- α )*(x+y)/2               OR-connecting function


3.11 Set product / two-dimensional member functions

3.11.1 General definitions
In practical applications it is often useful to join two standard fuzzy sets into one combined
fuzzy set called the "set product" or "product set" of both. A similar concept is also widely
used in traditional set theory.

Suppose we have two abstract entities A and B with two sets of base values {a} and { b}, two
sets of fuzzy values {f } and {g} and two member functions p(a,f) and q(b,g), respectively.
Entities A and B may be truly different but also may in fact be identical.



                                               28
Now look at two fuzzy sets P(f) = { [a,p(a,f)] } of abstract entity A and Q(g) = { [b,q(b,g)] }
of abstract entity B. n(x,y) be an arbitrary Norm or Conorm function. We then define the set
product of fuzzy sets P(f) and Q(g) as follows:

Z(f,g) = P(f)*Q(g) = { ( a, b, n[ p,(a,f),q(b,g) ] ); [a,p(a,f)]∈P(f); [b,q(b,g)])∈Q(g) }

In other words: Z is the set of all triples a,b,n where a and b are base values of A and B, f and
g are fuzzy values of A and B and n[ p,(a,f),q(b,g) ]=µ (a,b,f,g) denotes the combined mem-
bership of the pair (a,b) of base values to the pair (f,g) of fuzzy values under consideration.

If the pair (f,g) of fuzzy values is considered to be _AND_ connected, that is
(f,g) = f_AND_g, one normally chooses the Norm function n(x,y) to be a T-Norm function.
If, conversely, (f,g) = f_OR_g then the connecting function n(x,y) should be an S-Norm
function. In general the selection of n(x,y) depends upon usefulness.


3.11.2 Projections of two-dimensional member functions
If in a two-dimensional member function µ(a,b,f,g) = n[ p(a,f),q(b,g) ] variables b and g are
held to fixed values b=b0 and g=g0 of abstract entity B then the function ν(a,f) = µ(a,b0,f,g0) is
called "the projection of membership function µ(a,b,f,g) on the value pair (b0,g0) of abstract
entity B". ν(a,f) depends only upon the two variables a and f and represents the membership
of base values a to fuzzy values f of abstract entity A when only those cases are considered
where abstract entity B has its sharp value b0 and its fuzzy value g0 . There are as many pro-
jections ν(a,f) of two-dimensional membership function µ(a,b,f,g) as there are possible com-
binations (b0,g0).

Similarly projections ν(b,g) = µ(a0,b,f0,g) on the value pairs (a0,,f0) of abstract entity A are
defined.


3.11.3 Two-dimensional fuzzy sets
The triples (a,b,m) with a and b from the sets of base values of abstract entities A and B, re-
spectively, and 0 ≤ m ≤ 1 are the elements of the "two-dimensional fuzzy set" of abstract en-
tities A and B:

M = { (a,b,m); a,b base values of A respective B; 0 ≤ m ≤1 }

In this set every pair (a,b) of sharp values is contained with its membership m to both ab-
stract entities A and B simultaneously - obviously a generalization of the one-dimensional
fuzzy sets discussed earlier .

Consequently we can also define set operations for two-dimensional fuzzy sets.

Complement set
⌐M = { (a,b,1-m)

Intersection
M1∩ M2 = { [a,b, T(m1,m2)]; } with a suitable T-Norm function


                                               29
Junction
M1∪M2 = { [a,b, S(m1,m2)] } with a suitable S-Norm function


3.12 Multi dimensional member functions

3.12.1 Definition
The above reasoning may be easily generalized for an arbitrary number of abstract entities

The n-tupel of base values a1,...,aN of abstract entities A1,...AN simultaneously belong to the
n-tuels of fuzzy values f1,...,fN of the same abstract entities A1,...AN with membership

µ(a1,...,aN,f1,...fN) = n[p1(a1,f1),...,pN(aN,fN) ]

where n(x1,...,xN) is any agreed T-Norm or S-Norm function.

If the multiple (f1,...fN) of fuzzy values is AND-connected one normally chooses n(x1,...,xN)
to be a T-Norm function. If, conversely, (f1,...fN) is OR - connected the connecting function
n(x1,...,xN) should be an S-Norm function.


3.12.2 Projections
Projections of multi-dimensional membership functions are defined similarly as for two-
dimensional membership functions. One or more of the sharp and related fuzzy variables are
held constant, the others may vary freely. Projected functions give the memberships of base
values to fuzzy values of certain abstract entities when only those cases are considered where
the other abstract entities have definite fixed sharp and fuzzy values .


3.12.3 Fuzzy sets
Also this is a straightforward generalization of the two-dimensional case. The combinations
(a1,...,aN,m) with a1,...aN from the sets of base values of the abstract entities A1,...AN and m
between 0 and 1 are the elements of an "N-dimensional fuzzy set":

M = { (a1,...,aN,m); a1,...aN are base values of A1,...AN; 0 ≤ m ≤1 }

M may be a product set of several one-dimensional fuzzy sets:

M1(f1) = { (a1,m1); a1 ∈ set of base values of abstract entity A1; m1 membership of a1 to f1}
M2 (f2)= { (a2,m2); a2 ∈ set of base values of abstract entity A2; m2 membership of a2 to f2}
....
MN (fN)= { (aN,mN); aN∈set of base values of abstract entity AN;mN membership of aN to fN}

M(f1, f2,...,fN) = { (a1,...,aN,T(m1,...,mN) } = M1(f1)*...*MN(fN)
respectively
M(f1, f2,...,fN) = { (a1,...,aN,S(m1,...,mN) } = M1(f1)*...*MN(fN)



                                                      30
3.13 Example
The following example shows how two-dimensional member functions are constructed and
used. The notations are similar to those of the preceding chapter.


Abstract entities      A: temperature                        B: pressure
Physical units         Kelvin (°K)                           105 Pascal (105Pa)
Sets of base values    {a} = { a; 0 ≤ a ≤ 1000 }             {b} = { b; 1 ≤ b ≤ 10 }
Sets of fuzzy values   {f} = { cold, warm, hot }             {g} = { low, middle, high }
Membership functions   p(a,f)                                q(b,g)
p(a, cold) =           1                 if 0 ≤ a ≤ 300
                       1 - (a-300)/400 if 300 ≤ a ≤ 700
                       0                 if 700 ≤ a ≤ 1000
p(a, warm) =           a/300             if   0 ≤ a ≤ 300
                       1                 if 300 ≤ a ≤ 700
                       1 - (a-700)/300 if 700 ≤ a ≤ 1000
p(a, hot) =            0                 if 0 ≤ a ≤ 300
                       (a-300)/400       if 300 ≤ a ≤ 700
                       1                 if 700 ≤ a ≤ 1000
q(b, low) =                                                  1              if 1 ≤ b ≤ 3
                                                             1 - (b-3)/4 if 3 ≤ b ≤ 7
                                                             0             if 7 ≤ b ≤ 10
q(b, middle) =                                               b/3            if 1 ≤ b ≤ 3
                                                             1             if 3 ≤ b ≤ 7
                                                             0 - (b-7)/3   if 7 ≤ b ≤ 10
q(b, high) =                                                 0              if 1 ≤ b ≤ 3
                                                             (b-3)/4       if 3 ≤ b ≤ 7
                                                             1             if 7 ≤ b ≤ 10
Fuzzy sets             P(f) = { (a, p(a,f) }                 Q(g) = { (b, q(b,g) }
P(cold) =              { [ a, p(a,cold) ]; 0 ≤ a ≤ 1000 }
P(warm) =              { [ a, p(a,warm) ]; 0 ≤ a ≤ 1000 }
P(hot) =               { [ a, p(a,hot) ];   0 ≤ a ≤ 1000 }
Q(low) =                                                     { [ b, q(b,low) ];      0 ≤ b ≤ 10 }
Q(middle) =                                                  { [ b, q(b,middle) ];   0 ≤ b ≤ 10 }
Q(high) =                                                    { [ b, q(b,high) ];     0 ≤ b ≤ 10 }
Table 12
Membership functions p(a,f) of temperature and q(b,g) of pressure;
Fuzzy sets P(f) of temperature and Q(g) of pressure




                                              31
Infix                             _AND_                                      _OR_
Two-dimensional      cold_AND_low; cold_AND_middle;             cold_OR_low; cold_OR_middle;
fuzzy values         cold_AND_high;                             cold_OR_high;
                     warm_AND_low; warm_AND_middle;             warm_OR_low; warm_OR_middle;
                     warm_AND_high;                             warm_OR_high;
                     hot_AND_low; hot_AND_middle;               hot_OR_low; hot_OR_middle;
                     hot_AND_high;                              hot_OR_high;
Norm function        min(x,y)                                   max(x,y)
Table 13 Two-dimensional fuzzy values with _AND_ respective _OR_ connection

            a        0       100 200 300      400   500   600    700 800 900    1000
       p(a,warm)     0       0.33 0.67 1       1     1     1      1 0.67 0.33     0
   b   q(b,high)
   0             0       0      0      0    0    0    0    0    0    0    0         0
   1             0       0      0      0    0    0    0    0    0    0    0         0
   2             0       0      0      0    0    0    0    0    0    0    0         0
   3             0       0      0      0    0    0    0    0    0    0    0         0
   4          0.25       0   0.25   0.25 0.25 0.25 0.25 0.25 0.25 0.25 0.25         0
   5          0.50       0   0.33   0.50 0.50 0.50 0.50 0.50 0.50 0.50 0.33         0
   6          0.75       0   0.33   0.67 0.75 0.75 0.75 0.75 0.75 0.67 0.33         0
   7             1       0   0.33   0.67    1    1    1    1    1 0.67 0.33         0
   8             1       0   0.33   0.67    1    1    1    1    1 0.67 0.33         0
   9             1       0   0.33   0.67    1    1    1    1    1 0.67 0.33         0
  10             1       0   0.33   0.67    1    1    1    1    1 0.67 0.33         0
Table 14
Partial two-dimensional membership function
µ(a,b,warm_AND_high) = min[ p(a,warm), q(b,high) ]




                                                 32
          a      0   100 200     300 400 500 600 700              800    900   1000
      p(a,hot)   0    0    0      0 0.25 0.50 0.75 1               1      1     1
  b   q(b,low)
  0           1    1    1    1      1      1      1      1   1      1      1      1
  1           1    1    1    1      1      1      1      1   1      1      1      1
  2           1    1    1    1      1      1      1      1   1      1      1      1
  3           1    1    1    1      1      1      1      1   1      1      1      1
  4        0.75 0.75 0.75 0.75   0.75   0.75   0.75   0.75   1      1      1      1
  5        0.50 0.50 0.50 0.50   0.50   0.50   0.50   0.75   1      1      1      1
  6        0.25 0.25 0.25 0.25   0.25   0.25   0.50   0.75   1      1      1      1
  7           0    0    0    0      0   0.25   0.50   0.75   1      1      1      1
  8           0    0    0    0      0   0.25   0.50   0.75   1      1      1      1
  9           0    0    0    0      0   0.25   0.50   0.75   1      1      1      1
 10           0    0    0    0      0   0.25   0.50   0.75   1      1      1      1
Table 15
Partial two-dimensional membership function
µ(a,b,hot_OR_low) = max [ p(a,hot),q(b,low) ]

The other two-dimensional partial membership functions have similar value tables

      a        0     100    200 300     400    500    600 700     800    900 1000
p(a,cold)        1      1      1    1   0.75   0.50   0.25    0      0      0    0
p(a,warm)        0   0.33   0.67    1      1      1      1    1   0.67   0.33    0
p(a,hot)         0      0      0    0   0.25   0.50   0.75    1      1      1    1
ν(a,cold)     0.75   0.75   0.75 0.75   0.75   0.50   0.25    0      0      0    0
ν(a,warm)        0   0.33   0.67 0.75   0.75   0.75   0.75 0.75   0.67   0.33    0
ν(a,hot)         0      0      0    0   0.25   0.50   0.75 0.75   0.75   0.75 0.75
Table 16
Projection ν(a,f) of two-dimensional membership function µ(a,b,f_AND_g)
on value pair b = b0 = 6*105Pa (sharp) and g = g0 = "high" (fuzzy)
of abstract entity pressure
ν(a,f) = µ( a, 6, f_AND_high ) = min[ p(a,f), q(6,high) ] = min [ p(a,f), 0.75 ]




                                               33
      a        0     100    200 300     400    500    600 700     800    900 1000
p(a,cold)        1      1      1    1   0.75   0.50   0.25    0      0      0    0
p(a,warm)        0   0.33   0.67    1      1      1      1    1   0.67   0.33    0
p(a,hot)         0      0      0    0   0.25   0.50   0.75    1      1      1    1
ν(a,cold)        1      1      1    1   0.75   0.75   0.75 0.75   0.75   0.75 0.75
ν(a,warm)     0.75   0.75   0.75    1      1      1      1    1   0.75   0.75 0.75
ν(a,hot)      0.75   0.75   0.75 0.75   0.75   0.75   0.75    1      1      1    1
Table 17
Projection ν(a,f) of two-dimensional membership function µ(a,b,f_OR_g)
on value pair b = b0 = 6*105Pa (sharp) and g = g0 = "high" (fuzzy)
of abstract entity pressure.
ν(a,f) = µ( a, 6, f_OR_high ) = max[ p(a,f), q(6,high) ] = max [ p(a,f), 0.75 ]

Fuzzy sets:
M(f_AND_g) = { (a, b, m); a,b base values of temperature respectively. pressure; 0 ≤ m ≤1 }
            = { (a, b, µ(a,b,f_AND_g) } = { (a, b, min[ p(a,f), q(b,g) ] }

M(f_OR_g) = { (a, b, m); a,b base values of temperature respectively. pressure; 0 ≤ m ≤1 }
          = { (a, b, µ(a,b,f_OR_g) } = { (a, b, max[ p(a,f), q(b,g) ] }




                                               34
4 Fuzzy Controllers

4.1 Introduction
As described earlier processes in real world can be characterized by time-dependant values
of certain abstract entities. Those entities may be classified as "input variables" and "output
variables" to the process. Generally spoken input variables determine the time dependant pro-
cess flow whereas output variables describe the momentary process states. Some of the input
variables can be influenced more or less accurately by operating staff persons or by comput-
ers. These are the "control variables" of the process. Other input variables either cannot easily
be controlled at all (that is their values are accidental) or are not considered being important
in the context. Process control in its widest sense means operating a process in a "closed loop"
with the aim of producing best results in some sense, that is of producing optimum values of
some or all output variables. The basic principle is pretty simple:

•   determine the present values of all relevant output variables
•   compare these present output values to given target values
•   adjust values of suitable control variables such as to approach the
    target values better than before
•   repeat above steps forever (or until target values have been met sufficiently exact)

In the example below the process has three input variables among which there are two control
variables (input 2 and input 3) and one accidental variable (input 1). The process also has
three output variables which are all used for control. The controller (might be a fuzzy con-
troller) uses the three output variables, transforms them according to some algorithm into two
control variables which are then "fed back" as control inputs to the process. Comparison of
output values to target values is done within the controller itself.




                                               35
                                                   Process

 Input 1                                                                       Output 1




 Input 2                                                                       Output 2




 Input 3                                                                       Output 3




                                                     Controller



A fuzzy controller performs exactly as described. Its only peculiarity is its method of trans-
forming output values into control values. Most standard controllers do that by pretty com-
plicated mathematical computations. A fuzzy controller uses "rules" similar to those used by
human operators.

Examples
IF pressure is low THEN open valve considerably
        A chemical production process
IF interests are high THEN reduce obligations greatly
        A financial planning process
IF energy consumption is low THEN reduce generator input power to near standby
        A power plant process




                                             36
Without loss of clearness these phrases may be reduced to
IF pressure.low THEN valve.open_considerably
IF interests.high THEN obligations.reduce_greatly
IF energy consumption.low THEN generator.reduce_ input_ power_ to_ near_ standby


The underlined terms are names of abstract entities, the italicized terms are fuzzy values of
respective abstract entities, the cancelled terms are redundant and may be omitted.

Rules like these are suitable for human process control. An experienced operator knows what
terms like "pressure is low" or "open valve considerably" really do mean. But automatic con-
trol devices deal with sharp numbers and not with fuzzy values: the output variables of many
technical process are treated by analog-to-digital converters, the control variables by digital-
to-analog converters, both kinds of devices are restricted to numeric value processing.

So to set up a fuzzy controller basically we have to do three things:

•     transform sharp values of process output variables into fuzzy values
•     use rules to transform fuzzy output variable values into fuzzy values of the control vari-
      ables
•     transform fuzzy values of the control variables into sharp values

The first task, transformation of sharp values to fuzzy values, was treated in Chapter 2. For
each abstract entity A of the process we define a member function µ(a,f) which attaches any
sharp value a of A to each of the agreed fuzzy values f of A.

The second and third tasks will be discussed now


4.2     Rules, implications, conclusions

4.2.1 Rules
A rule in a fuzzy control system has the general form

IF f0 THEN g0

where f0 and g0 are any two fixed fuzzy values of some output variable A and some control
variable B of the process under consideration.

Example
Consider a process with

•     3 output variables:
      pressure           with fuzzy values { pressure.low, pressure.middle, pressure.high }
      temperature        with fuzzy values { temp.cold, temp.lukewarm, temp.warm, temp.hot }
      moisture           with fuzzy values { moisture.dry, moisture.moist, moisture.wet }




                                                 37
•   2 control variables:
    valve              with fuzzy values { valve.closed, valve.half_open, valve.open }
    heater             with fuzzy values { heater.off, heater.low, heater.middle, heater.max }

There might be two rules:

•   IF pressure.low THEN valve.half_open
        f0 = pressure.low
                fuzzy value of output variable "pressure"
        g0  = valve.half_open
                fuzzy value of control variable "valve"

•   IF temp.cold_AND_moisture.wet THEN heater.max
        f0 = temp.cold_AND_moisture.wet
                combined fuzzy value of output variables "temperature" and "moisture"
        g0 = heater.max
                fuzzy value of control variable "heater"

The value f0 in the IF-part of a rule (the precondition) may either be a simple fuzzy value of
one output variable or a combination of fuzzy values of several output variables. The fuzzy
value g0 in the THEN-part of a rule (the conclusion part) is nearly always a simple fuzzy
value of only one control variable.




                                               38
4.2.2 Implications
Terms like "IF f0 THEN g0" also occur in boolean logic and there are called implications. f 0
and g0 are considered being boolean entities with attached truth values 0 or 1. Formally an
implication is written f0→g0 and for each pair of truth values of f 0 and g0 returns a result
according to following table:

f0   g0   f0 → g0   (⌐f0) ⋁g0
0    0       1           1
0    1       1           1
1    1       1           1
1    0       0           0

Table 18 Truth table of boolean functions f0 → g0 and (⌐f0) ⋁g0

Clearly f0 →g0 is equivalent to (⌐f0)⋁g0

In fuzzy logic the implication f0 →g0 may be defined for fuzzy values f0 and g0 as a new
combined fuzzy value

Definition of fuzzy implication:       (NOT_f0)_OR_g0

Membership function:                   µ(a,b, f0 →g0) =
                                       µ [ a,b, (NOT_f0)_OR_g0 ] =
                                       S[ 1-m(a, f0), n(b,g0 ) ]

Here a and b are any two base values of the respective abstract entities A and B to which f0
and g0 belong. m(a, f0) and n(b,g0 ) are respective partial member functions of A and B.


4.2.3 Combination of process states and rules
As an introduction consider a process with only one output variable A, one control variable B
and one rule connecting two selected fuzzy values f 0 of A and g0 of B.

                        Output variable      Control variable
Name:                          A                    B
Base values:                   {a}                  {b}
Fuzzy values:                  {f}                  {g}
Member functions:              m(a,f)               n(b,g)
Selected fuzzy values:          f0 ∈ {f}            b0 ∈ {g}
Present sharp values:           α(t) ∈{a }           β ∈{b }
Rule:                                  IF f0 THEN b0




                                               39
The situation may by described as follows.

•   At any time t sharp value α(t) of output variable A belongs to fuzzy value f0 with mem-
    bership m(α,f0)

    AND

At any time t and for any sharp value b of control variable B the pair (α , b) belongs to the
fuzzy value f0 →g0 = (NOT_f0)_OR_g0 with membership
 µ(α , b, f0 →g0) = S[ 1-m(α, f0), n(b,g0 ) ]

Regarding the situation as a whole we should look at the AND_combined fuzzy values from
both phrases, that is at fuzzy value

•   f0_AND_[f0 →g0] = f0 _AND_[(NOT_f0)_OR_g0 ]

At any time t and for any sharp value b of B the pair (α , b) belongs to this new fuzzy value
with membership

•   r(α, b, f0 _AND_ [(NOT_f0)_OR_g0 ] = T{ m(α, f0), S[ 1-m(α, f0), n(b,g0 ) ] }

For fixed time t and therefore fixed value α(t) this function depends solely on b.

4.2.4 How to select a sharp value of control variable B
After the foregoing considerations the answer is obvious:

For any fixed time t=t0 the sharp value b=β(t0) of control variable B should be chosen such as
to maximize the membership of the pair [α(t0),b] to fuzzy value f0 AND_ [(NOT_f0)_OR_g0 ]:

T{ m(α, f0), S[ 1- m(α, f0), n(b,g0 ) ] } = max.       for b=β(t)=bmax

This formalism contains the basic concept of fuzzy control. It permits the determination
of control variable values β(t) for a process from the output values α(t) by means of
colloquial rules.


4.2.5 Details
Let us discuss the behavior of the function

ρ(b) = T{ m(α(t0), f0 ) , S[1-m(α(t0) ), f0 ), n(b,g0 )] } = T{ m0 , S[1-m0, n(b,g0 )] }

for a fixed time t=t0 , that is for a fixed value m0 of m. ρ(b) gives the membership of the pair
of sharp values [α(t0), b] of output variable A at time t=t0 and control variable B to fuzzy
value f0 _AND_[(NOT_f0)_OR_g0]. As said before should be chosen such that ρ(b) is maxi-
mum for b=β(t0)=bmax.




                                                 40
4.2.5.1 Precondition of rule highly fulfilled (m≈1)
This means m≈1 and therefore ρ(b) ≈ T{1, S[0, n(b,g0 )] } = T{1, n(b,g0 )] } = n(b,g0 ). Ac-
cordingly control value b should be chosen such as to let membership n(b,g0 ) become a
maximum. This seems reasonable: if the preconditions of the rule are nearly fully met then
the rule should be executed as effectively as possible.


4.2.5.2 Precondition of rule partly fulfilled (m≤0.5)
Now we have S[1-m, n(b,g0 )] ≥ max [1-m, n(b,g0 )] ≥ 0.5 ≥ m and therefore
ρ(b) = T{m, S[1-m, n(b,g0 )] } ≤ min {m, S[1-m, n(b,g0 )]} ≤ m. The lower the value of m, the
lower membership ρ(b) for any choice of b so that the actual selection of b becomes less
significant.


4.2.5.3 Precondition of rule hardly or not fulfilled (m ≈ 0)
Now ρ(b) ≈ T{0, S[1, n(b,g0 )] } = T{0, 1} = 0 independent of b and the choice of b is ir-
relevant as any value will suffice. This corresponds to everyday experience that rules whose
preconditions are not met need not be fulfilled.


4.2.6 Two examples

4.2.6.1 T(x,y) = drastic product(x,y) / S(x,y) = drastic sum(x,y)
This gives
ρ(b) = 0            if m<1
ρ(b) = n(b,g0)      if m=1

Only if the process output value α(t) fully belongs to the precondition f0 of the rule the calcu-
lation of an optimum value β=bmax is meaningful, otherwise choice of b is irrelevant.




                                               41
4.2.6.2 T(x,y) = min(x,y) / S(x,y) = max(x,y)
This results in ρ(b) = min{m, max[1-m, n(b,g0 )] } the values of which are given in following
table.


m                n(b,g0 )                    ρ(b) =
0 ≤ m ≤ 0.5      irrelevant                  m
0.5 ≤ m ≤ 1.0       0 ≤ n(b,g0 ) ≤ 1-m       1-m
                 1-m ≤ n(b,g0 ) ≤ m          n(b,g0 )
                   m ≤ n(b,g0 ) ≤ 1          m
Table 19
The table shows:
• If preconditions of the rule are poorly satisfied ( m ≤ 0.5) function ρ(b) does not at all de-
   pend on variable b and therefore the choice of b is irrelevant ... as common sense predicts
• If preconditions of the rule are better satisfied then we have to distinguish:
       for values of b for which n(b,g0 ) is small (0 ≤ n(b,g0 ) ≤ 1-m)
               function ρ(b) does not depend on b but has the small constant value ρ(b) = 1-m
       for values of b for which n(b,g0 ) is medium (1-m ≤ n(b,g0 ) ≤ m)
               function ρ(b) = n(b,g0 ) can be used to determine β=bmax
       for values of b for which n(b,g0 ) is big (m ≤ n(b,g0 ) ≤ 1)
               function ρ(b) does not depend on b but has the big constant value ρ(b) = m

Summary:
• If n(b,g0 ) is too small ( 0 ≤ n(b,g0 ) ≤ 1-m for all values of b) all values of b equally
   conform to the rule and to the momentary process state. There is no significant choice b=β
• Also if n(b,g0 ) is too big (m ≤ n(b,g0 ) ≤ for all values of b ) all values of b equally con-
   form to the rule and to the momentary process state and again there is no significant
   choice β=bmax .
• Only if n(b,g0 ) is neither too small nor too big (1-m ≤ n(b,g0 ) ≤ m for all values of b )
   then ρ(b)=n(b,g0) depends sufficiently on b to permit the calculation of an optimum value
   b=β.

4.2.7 Final modification
The above examples cannot easily be generalized to other Triangular Norm and Conorm
functions because the mathematical representations of ρ(b) = T{m, S[1-m, n(b,g0 )] } tend to
become rather complex. So a simplification seems necessary. The most interesting cases are
those where memberships m(α(t),f0 ) and n(b,g0 ) are both close to 1, resulting in
S[1-m, n(b,g0) ] ≈ S[0, n(b,g0 )] = n(b,g0 ). In these cases we may approximately set ρ(b) ≈
T{m, n(b,g0 ) }

We will now treat

ρ ( b ) = T { m( α(t), f0 ) , n( b, g0 ) }




                                               42
not only as an approximation but as a new simplified definition for ρ(b) valid for all values of
m(α(t),f0 ) and n(b,g0) regardless of their magnitudes.

The new definition in fact gives the membership of base value pair [α(t), b] to fuzzy value
f0_AND_g0 instead to original fuzzy value f0_AND_[(NOT_f0)_OR_g0]. In boolean logic
this would not make a difference since we have f0 ⋀ (f0 →g0) = f0 ⋀( (¬f0) ⋁ g0) =
(f0 ⋀ (¬f0)) ⋁ (f0 ⋀ g0)) = f0 ⋀ g0 but for fuzzy values f0 and g0 similar relations do not
apply.

From now on we will use only the simplified definition ρ( b ) = T { m( α, f0 ) , n( b, g0 ) }
if not otherwise said


4.2.8 Combined preconditions
Rules like

IF pressure.low_OR_pressure.medium THEN valve.open

or

IF temp.cold_AND_moisture.wet THEN heater.full

with combined preconditions are treated similarly as before. It makes no difference whether
the combined preconditions refer to only one or to more than one output variables. In both
cases from the sharp output value(s) α1(t), ... , αN(t) at time t the degree of membership
m( α1(t), ... , αN(t), f0 ) to the combined fuzzy value f0 is determined. After that we may pro-
ceed as before, that is we consider function ρ ( b ) = T { m(α1(t), ... , αN(t), f0 ) , n( b, g0 ) }
and try to find an optimum value for b.


4.3   Accumulation and De-Fuzzification

4.3.1 Several simultaneous rules
Consider a set of rules like the following for car driving

IF distance.near       THEN speed.slow
IF time.short          THEN speed.fast
IF date.weekend        THEN speed. fast
IF fuel.empty          THEN speed.stop
IF money.short         THEN speed.economy

All rules refer to the same output variable "speed" with its fuzzy values "stop", "slow",
"economy" and "fast" (among others). The rules may lead to coincident or to contradictory
conclusions depending on how the preconditions actually are fulfilled in a certain driving
situation. If, for example, time and money happen to be "short" simultaneously, should speed
then be "fast" or "economy" ?




                                                43
If there are several rules simultaneously we have to decide which of them to fulfill:
rule1 OR rule2 OR rule3 OR rule4 OR rule5

OR in this context means "inclusively-OR" as several rules may ( and if possible should ) be
fulfilled simultaneously.

A rule with precondition f0 and conclusion g0 is equivalent to fuzzy value f0_AND_g0 . At any
time t the sharp process output value(s) together with value b of the control variable to which
the rule refers should result in optimum membership ρ0(b) = T{ m(α1(t), ... , αN(t), f0 ),
n( b, g0 ) } to f0_AND_g0. Several rules together one or more of which should be fulfilled
simultaneously are equivalent to the combined fuzzy value

(f1_AND_g1)_OR_(f2_AND_g2)_OR_....._OR_(f3_AND_g3)

with membership function

ρ( b ) = S { ρ1( b ), ρ2( b ),....., ρN( b ) }

where

ρ1 ( b ) = T { m(α1(t), ... , αN(t), f0 ) , n( b, g1 )                       }   rule #1
ρ2 ( b ) = T { m(α1(t), ... , αN(t), f0 ) , n( b, g2 )                       }   rule #2
ρ3 ( b ) = T { m(α1(t), ... , αN(t), f0 ) , n( b, g3 )                       }   rule #3
..........................................................................       ........
ρN ( b ) = T { m(α1(t), ... , αN(t), f0 ) , n( b, gN)                        }   rule #N

are respective membership functions from each of the rules.

As before ρ( b ) = S { ρ1( b ), ρ2( b ),....., ρN( b ) } at any fixed time t is a function of b alone
from which the optimum value of b=β may be determined.


4.3.2 De-Fuzzification
The foregoing chapters discussed how to derive from the control rules and the momentary
process state an "optimum" value β of control variable b. This procedure called de-
fuzzification is the last step of each control cycle in a fuzzy system. Generally said b=β
should make partial membership function

ρ(b) = S { ρ1(b), ρ2(b),.., ρN(b) } = S {T[m1,n( b, g1 )], T[m2,n( b, g2 )],..,T[mN,n( b, gN )] }

"optimal" or "maximal" or anything similar. But what does that really mean ? In fact three
different methods are used for de-fuzzyfication which will be described now




                                                                         44
4.3.2.1 Method of maximum height
This method is always applicable if function ρ( b ) has a definite absolute maximum at some
value b=bmax that is if ρ( bmax ) ≥ ρ( b ) for all values of b. Value b = bmax may then be used.
The method has the advantage of being very simple and straightforward, a disadvantage lies
in the fact that function ρ( b ) is not considered in its whole area of definition but only at its
maximum position. This might lead to inappropriate results.


4.3.2.2 Method of mean of maximum
If function ρ( b ) has several relative maxima the (weighted) average of these can be taken.
Thereby the general form of ρ( b ) is better taken into account than before. The method is also
applicable if ρ( b ) is constant over certain intervals of b which happens rather often in prac-
tice. In this case one takes the centers of each such interval as "relative local maximum" and
these values are then averaged.


4.3.2.3 Method of center of gravity
A graphical representation of function ρ( b ) in a Cartesian coordinate system is a curve which
together with the abscissa (the b-axis) and the upper and lower bounds for b borders a flat area
of the coordinate plain. Then the abscissa β of its center of gravity is taken as the desired
"optimum"
                   d
M         =        ò
                   c
                       b * ρ ( b ) * db

               d
F         =    ò
               c
                       ρ ( b ) * db

b   opt       = M              / F

If ρ( b ) is defined only for discrete values of b (so called singletons ) computation or the
center of gravity is modified somewhat:

M         =            b   n   * ρ (b n)
               n
F =                    ρ (b n)
              n
b   opt       = M          / F




                                               45
5 Fuzzy Numbers and Fuzzy Intervalls

5.1 Problem
When evaluating scientific experiments often the following situation arises:
Suppose the outcome of an experiment is a set of real numbers. Because of inadequate ex-
perimental design, measuring inaccuracies or other disturbing effects the result values are not
fully accurate but always are more or less faulty. Now consequences from the results shall be
derived. If the outcome values were accurate the same would hold for the consequences: they
were definitely certain. But as in fact the results are inherently faulty also the consequences
will be to some degree uncertain. So the question of reliability comes up:

If the inaccuracies of the result values are known, what degree of uncertainty is to be expected
for the consequences ? How can one calculate the degree of uncertainty ? What are the limits
of reliability ?

All these questions and more may be treated in depth by means of probability theory, general
statistics, sampling theory and related techniques. The Gaussian method of least squares to-
gether with error propagation law is a good example. Below we give another approach using
fuzzy methods. By doing so the aim is not to replace the well-proven traditional methods but
to offer them a supplement.


5.2     Relations

5.2.1 One independent variable
As shown in chapter 2 numbers can be given either as sharp numbers x from some set of base
values {x} or as fuzzy numbers f from some set {f}of fuzzy values. Both representations are
connected to each other by the membership function m(x,f) respectively by the fuzzy sets X(f)
= { (x, m[x,f]) }.

A function w=fun(x) is an algorithm by which to each sharp number x from {x} exactly one
sharp number w from a certain set {w} of real numbers is connected. w = fun(x) is the "pic-
ture " of x under function fun(x): x: →w. Can we give similar definition for functions of fuzzy
numbers ?

Let f0 be some fuzzy number (e.g. f0 =about_3.4) and X(f0) = {(x,m(x,f0) } the related fuzzy
set. We now construct another fuzzy set W as follows:

•     Let (x0,m0) be any element of fuzzy set X(f0). Then from x0 a sharp value w0 is calcu-
      lated by
      w0 = fun(x0)
•     A membership r(w0) is calculated as follows:
         1.) All elements (x,m)∈X(f0) with fun(x)=w0 are collected
                  (besides x0 there might be other numbers x with fun(x)=w0 )
                  Let these elements be (x0,m0); (x1,m1); ...; (xN,mN)
         2.) r0 is calculated as r0= S(m0, m1,...,mN) with some formerly agreed Conorm S.



                                               46
•   Let W = {(w,r ) } be the set of all pairs (w,r ) = (w0,r0 ) calculated in that way for all pos-
    sible elements (x0,m0)∈ X(f0)

We may consider W as being the fuzzy set of a certain (yet unnamed) fuzzy number p0 de-
fined on the set {w} of base values w. This fuzzy number is regarded as the "picture" p0 =
fun(f0) of f0 under function fun(f) just as w0=f(x0) is the picture of x0 under function fun(x).
So W becomes W(fun(f0)). Generally for any fuzzy number from {f}:               x: → w=fun(x),
f: → p=fun(f), X(f): → W(p)

Definition
If fuzzy set W is constructed from fuzzy set X as described above we say there is a relation
between X and W or symbolically X: →W

But there is a difficulty:
If X contains only a finite number of elements (x,m) then we have also only a finite number
of values m0, m1,...,mN and expression S(m0, m1,...,mN) is well defined. But if X contains an
infinite number of elements then also m1,...,mN might be an infinite sequence for which till
now S is not defined. So at first the definition of S should be extended to an infinite number
of arguments. Unfortunately this cannot be done for all Conorm functions in general but only
for some special ones. One of these is S(x0,x1,...) = max(x0,x1,...) and so for an infinite set X
(practically the most important case) we restrict ourselves to that definition of S. For finite
fuzzy sets X any definition shall be allowed.

Example
Set of base values :         {x; x any real number}
Fuzzy number f0 :            about_3.40
                                                    − 20 * (3.4 − x) 2
Membership :                m(x, about_3.4) = e
Fuzzy set :                 X(about_3.4) = { (x, m(x, about_3.4) }
Function :                  w(x) = fun(x) = 3/x - x/5
                                              − 20 * (3.4 − x) 2
Membership :                r(w0) = max { e                         ; 3/x - x/5 = w0 }

Which values of x should be considered in determining r(w0) ?

3/x - x/5 = w0
3 - x 2 /5 - w0 * x = 0
x 2 + 5 * w0 * x − 15 = 0
x1 / 2 = −5 * w0 / 2 ± (25 * w0 2 / 4 + 15)

With these values x1 and x2 we finally get
                                              − 20 * (3.4 − x1) 2         − 20 * (3.4 − x 2) 2
Membership :                r(w0) = max { e                         , e                          }




                                                     47
The following tables give respective values which are visualized in the diagram. The values
x0 and x1 respectively m(x0,f0) and m(x1,f0) should be identical. The small occasional
differences are due to rounding inaccuracies.

   x0           2.50 2.80 2.90 3.00 3.05 3.10 3.15 3.20 3.25 3.30 3.35 3.40
m(x0,f0)        0.00 0.00 0.01 0.04 0.09 0.17 0.29 0.45 0.64 0.82 0.95 1.00
w0              0.70 0.51 0.45 0.40 0.37 0.34 0.32 0.30 0.27 0.25 0.23 0.20
x1              2.50 2.80 2.91 3.00 3.06 3.12 3.15 3.19 3.26 3.30 3.34 3.41
x2             -6.00 -5.35 -5.16 -5.00 -4.91 -4.82 -4.75 -4.49 -4.61 -4.55 -4.49 -4.41
m(x1,f0)        0.00 0.00 0.01 0.04 0.10 0.21 0.29 0.41 0.68 0.82 0.93 1.00
m(x2,f0)        0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00
r(w0)           0.00 0.00 0.01 0.04 0.10 0.21 0.29 0.41 0.68 0.82 0.93 1.00
Table 20 Example of a relation

   x0           3.40 3.45 3.50 3.55 3.60 3.65 3.70 3.75 3.80           3.9   4.0   4.5
m(x0,f0)        1.00 0.95 0.82 0.64 0.45 0.29 0.17 0.09 0.04 0.01 0.00 0.00
w0              0.20 0.18 0.16 0.14 0.11 0.09 0.07 0.05 0.03 -0.01 -0.05 -0.23
x1              3.41 3.45 3.49 3.54 3.61 3.65 3.70 3.75 3.80 3.90 4.00 4.49
x2             -4.41 -4.35 -4.29 -4.24 -4.16 -4.10 -4.05 -4.00 -3.95 -3.85 -3.75 -3.34
m(x1,f0)        1.00 0.95 0.85 0.68 0.41 0.29 0.17 0.09 0.04 0.01 0.00 0.00
m(x2,f0)        0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00
r(w0)           1.00 0.95 0.85 0.68 0.41 0.29 0.17 0.09 0.04 0.01 0.00 0.00
Table 21 Example of a relation (continued)



                         Relation X(about_3.4):-->W

                1
               0,8
  m(x), r(w)




               0,6
               0,4
                                                                                         r(w)
               0,2                                                                       m(x)
                 0
                 -0.1 +0.35
                            ....             +2.75 +3.2
                                                        +3.65
                             w resp. x

Picture 3


                                                    48
5.2.2 Several independant variables
Relations may be generalized to more than one independent variable. Consider x and y being
sharp numbers from two sets of base values {x} and {y } and f and g being fuzzy number
from two sets of fuzzy values {f } and {g }. The related memebership functions are m(x,f)
resp. n(y,g), the fuzzy sets are X(f) = {(x,m(x,f) } and Y(g) = { (y,n(y,g) }. w=fun(x,y) be a
unique function which for any (allowed) pair (x,y) gives w as the "picture" of pair (x,.y):
(x,y)→w

Let now f0 and g0 be two fuzzy numbers (e.g. f0 = about_3.4 and g0 = about_5.9 ). X(f0) =
{(x,m(x,f0) } and Y(g0) = {(y,n(y,g0) } are the related fuzzy sets. We construct fuzzy set W as
follows:

•   Let (x0,m0) and (y0,n0) be any elements of fuzzy sets X(f0) and Y(g0) . Then from x0 and
    y0 a sharp value w0 is calculated by
    w0 = fun(x0,y0)
•   A membership r(w0) is calculated as follows:
        1.) All elements (x,m)∈X(f0) and (y,n)∈Y(g0) with fun(x,y)=w0 are collected
                 (besides (x0,y0) there might be other pairs (x,y) with fun(x,y)=w0 )
                 Let these elements be (x0,m0),(y0,n0); (x1,m1),(y1,n1); ... ;(xN,mN), (yN,nN)
        2.) r0 is calculated as r0= S(T(m0,n0), T(m1,n1),...,T(mN,nN) ) with some formerly
        agreed Norm function T and Conorm function S.
•   Let W = {(w,r ) } be the set of all pairs (w,r ) = (w0,r0 ) calculated in that way

The construction of W can be described equivalently using the concept of fuzzy set product.

•   Construct the set product Z(f0,g0) = X(f0) * Y(g0) with a suitably chosen T-Norm T(x,y):
    Z(f0,g0) = { (x,y, µ (x,y) } = Z{ (x,y,T[m(x,f0), n(y,g0)] ) }
•   To any element ( x0,y0, µ [x0,y0] ) of Z(f0,g0) calculate w0 = fun(x0,y0)
•   Calculate membership r(w0) as follows
        1. ) Collect all elements (x,y, µ [x,y] ) of Z(f0,g0) with fun(x,y)=w0
                 Let these elements be (x0,y0,µ0); (x1,y1,µ1); ... ;(xN,yN,µN)
        2.) r0 is calculated as r0= S(µ0, µ1,...,µN) with an agreed Conorm function S.
•   Let W = {(w,r ) } be the set of all pairs (w,r ) = (w0,r0 ) calculated in that way

We may consider W as being the fuzzy set of a certain (yet unnamed) fuzzy number p0 de-
fined on the set {w} of base values w. If necessary we give that fuzzy set p0 a suitable name
and regard it as the "picture" p0=fun(f0, g0) of pair (f0,g0) under function fun(x,y) similarly as
sharp number w=fun(x,y) is the "picture" of sharp number pair (x,y) under the same function:
(f0,g0): → p0 . Generally for any fuzzy number pair (f,g) : (f,g): → p or p=fun(f,g).

Again the same restrictions as before apply if the number of elements of Z is infinite. In that
case we delimit ourselves to the special cases T(x,y) = min(x,y) and S(x,y) = max(x,y).

Generalization to an arbitrary number of variables is obvious and does not need discussion.




                                                49
Example
Set of base values :      {(x, y); (x, y) pair of any real number}
Fuzzy numbers :           f0 = about_3.40
                         g0 = about_5.9
                                                 − 20 * (3.4 − x)2
Memberships :            m(x, about_3.4) = e
                                               − 10 * (5.9 − y )2
                         n(y, about_5.9) = e
Fuzzy sets :             X(about_3.4) = { (x, m(x, about_3.4) }
                         Y(about_5.9) = { (y, n(y, about_5.9) }
Function :               w(x, y) = fun(x, y) = x * y

Which     values    of     x     should     be      considered       in   determining   r(w0)   ?
x * y = w0 → y = w0/x

The following table shows for combinations (x0,y0) in the ranges 3.0≤x0≤3.8 and 5.4≤y0≤6.4
the resulting values w0 = x0*y0 together with memberships µ(w0) = min [m(x0,f0), n(y0,g0) ].
For product values w0 ≈16 to 24 in steps of ≈0.5 the positions with maximum membership
µ(w0) are underlined.




                                                  50
                        A      B      C      D       E      F      G      H      I
              x0       3.0    3.1    3.2    3.3     3.4    3.5    3.6    3.7    3.8
           m(x0,f0)   0.04   0.17   0.45   0.82    1.00   0.82   0.45   0.17   0.04
y0
n(y0,g0)
5.4                   16.2   16.7   17.3   17.8    18.4   18.9   19.4   20.0   20.5   a
0.08                  0.04   0.08   0.08   0.08    0.08   0.08   0.08   0.08   0.04   b
5.5                   16.5   17.1   17.6   18.2    18.7   19.3   19.8   20.4   20.9   c
0.20                  0.04   0.17   0.20   0.20    0.20   0.20   0.20   0.17   0.04   d
5.6                   16.8   17.4   17.9   18.5    19.0   19.6   20.2   20.7   21.3   e
0.41                  0.04   0.17   0.41   0.41    0.41   0.41   0.41   0.17   0.04   f
5.7                   17.1   17.7   18.2   18.8    19.4   20.0   20.5   21.1   21.7   g
0.67                  0.04   0.17   0.45   0.67    0.67   0.67   0.45   0.17   0.04   h
5.8                   17.4   18.0   18.6   19.0    19.7   20.3   20.9   21.5   22.0   i
0.90                  0.04   0.17   0.45   0.82    0.90   0.82   0.45   0.17   0.04   j
5.9                   17.7   18.3   18.9   19.5    20.1   20.7   21.2   21.9   22.4   k
1.00                  0.04   0.17   0.45   0.82    1.00   0.82   0.45   0.17   0.04   l
6.00                  18.0   18.6   19.2   19.8    20.4   21.0   21.6   22.2   22.8   m
0.90                  0.04   0.17   0.45   0.82    0.90   0.82   0.45   0.17   0.04   n
6.1                   18.3   18.9   19.5   20.2    20.7   21.4   22.0   22.6   23.2   o
0.67                  0.04   0.17   0.45   0.67    0.67   0.67   0.45   0.17   0.04   p
6.2                   18.6   19.2   19.8   20.5    21.1   21.7   22.3   22.9   23.6   q
0.41                  0.04   0.17   0.41   0.41    0.41   0.41   0.41   0.17   0.04   r
6.3                   18.9   19.5   20.2   20.8    21.4   22.1   22.7   23.3   23.9   s
0.20                  0.04   0.17   0.20   0.20    0.20   0.20   0.20   0.17   0.04   t
6.4                   19.2   19.8   20.5   21.1    21.8   22.4   23.0   23.7   24.3   u
0.08                  0.04   0.08   0.08   0.08    0.08   0.08   0.08   0.08   0.04   v
Table 22 Products w0 = x0*y0 and memberships r(w0)
Example for using the table:
w0 ≈ 19 is obtained by
x0=3.5 y0=5.4 m(x0,f0) = 0.82 n(y0,g0) = 0.08
       µ(w0) = min [0.82, 0.08) = 0.08 Col. F Lines a/b
x0=3.5 y0=5..5 m(x0,f0) = 0.82 n(y0,g0) = 0.20
       µ(w0) = min [0.82, 0.20) = 0.20 Col. F Lines c/d
x0=3.4 y0=5.6 m(x0,f0) = 1.00 n(y0,g0) = 0.41
       µ(w0) = min [1.00, 0.41) = 0.41 Col. E Lines e/f
x0=3.3 y0=5.7 m(x0,f0) = 0.82 n(y0,g0) = 0.67
       µ(w0) = min [0.82, 0.67) = 0.67 Col. D Lines g/h
x0=3.3 y0=5.8 m(x0,f0) = 0.82 n(y0,g0) = 0.90
       µ(w0) = min [0.82, 0.90) = 0.82 Col. D Lines i/j
x0=3.2 y0=5.9 m(x0,f0) = 0.45 n(y0,g0) = 1.00
       µ(w0) = min [0.45, 1.00) = 0.45 Col. C Lines k/l
x0=3.2 y0=6.0 m(x0,f0) = 0.45 n(y0,g0) = 0.90
       µ(w0) = min [0.45, 0.90) = 0.45 Col. C Lines m/n



                                              51
x0=3.1  y0=6.1 m(x0,f0) = 0.17 n(y0,g0) = 0.67
      µ(w0) = min [0.17, 0.67) = 0.17 Col. B Lines o/p
x0=3.1 y0=6.2 m(x0,f0) = 0.17 n(y0,g0) = 0.41
      µ(w0) = min [0.17, 0.41) = 0.17 Col. B Lines q/r
x0=3.0 y0=6.3 m(x0,f0) = 0.04 n(y0,g0) = 0.20
      µ(w0) = min [0.04, 0.20) = 0.04 Col. A Lines s/t
x0=3.0 y0=6.4 m(x0,f0) = 0.04 n(y0,g0) = 0.08
      µ(w0) = min [0.04, 0.08) = 0.04 Col. A Lines u/v

So we finally get
       r0(19) = S(µ0, µ1,...,µN)
               = max (0.08, 0.20, 0.41, 0.67, 0.82, 0.45, 0.45, 0.17, 0.17, 0.04, 0.04 ) = 0.82.
as approximate membership of
       w0 = 19
       in fuzzy set fun(f0, g0 ) = f0 * g0 = about_3.4 * about_5.9

Next two tables give memberships r(w0) for product values w0 ≈16 to 24 in steps of ≈0.5 as
read from above table.

w0    16.2      16.5   17.1   17.6   17.9   18.5    19.0   19.5   20.1
r(w0) 0.04      0.04   0.17   0.20   0.41   0.41    0.82   0.82   1.00
Table 23 Membership p(w0, about_3.4 * about_5.9 )

w0       20.4   21.0   21.4   22.0   22.3   22.9    23.3   23.9   24.3
r(w0)    0.90   0.82   0.67   0.45   0.41   0.17    0.17   0.04   0.04
Table 24 Membership p(w0, about_3.4 * about_5.9 ), continued




                                               52
                                Relation w=x*y



                 1
               0,8
 m(x), n(y),




               0,6
   r(w)




               0,4
               0,2                                       r(w)
                 0
                 2,5 3,5 4,5                           m(x)
                               5,5 6,5 ....
                                            16 21 26
                      x, y, w


                       m(x)         n(y)    r(w)

Picture 4




                                           53
6 Appendix

6.1   Proofs of common properties

6.1.1 Sequence of magnitude
We have to show

0≤0                            if max(x,y) < 1        Drastic product          (1)
0 ≤ min(x,y)                   if max(x,y) = 1                                 (2)
 ≤ max(0,x+y-1)                                       Limited difference       (3)
 ≤ x*y / { 1+(1-x)*(1-y) }                            Einstein product         (4)
 ≤ x*y                                                Algebraic product        (5)
 ≤ x*y / {1-(1-x)*(1-y) }                             Hamacher product         (6)
 ≤ min(x,y)                                           Minimum                  (7)
 ≤ max(x,y)                                           Maximum                  (8)
 ≤ 1 - (1-x)*(1-y) / (1-x*y)                          Hamacher sum             ( 9)
 ≤ 1 - (1-x)*(1-y)                                    Algebraic sum            (10)
 ≤ 1 - (1-x)*(1-y) / (1+x*y)                          Einstein sum             (11)
 ≤ min(1,x+y)                                         Limited sum              (12)
min(1,x+y) ≤ max(x,y)          if min(x,y) = 0                                 (13)
1≤1                            if min(x,y) > 0        Drastic sum              (14)

Here are the proves

1)     0≤0                     is always true

2)     0 ≤ min[x,y]            is always true

3)     if max(x,y) < 1
              then drastic product(x,y) = 0 ≤ max[0,x+y-1] = limited difference (x,y)
       if max(x,y) = 1
              then x = 1 or y=1
                      if x =1 then x+y-1 = y;
                              hence drastic product (x,y) = y = max(0,y) = max(0,x+y-1);
                      if y=1 then similar;
4)     if x+y≤1
              then max[0,x+y-1] = 0 ≤ xy/{1+[1-x][1-y]}
       if x+y>1
              then
                      2-x-y                  ≥      0
                      2-x-y+x*y              ≥      x*y
                      {1+[1-x]*[1-y]}        ≥      x*y
                      1                      ≥      x*y / {1+(1-x)*(1-y) }
                      (1-x)*(1-y)            ≥      x*y*(1-x)*(1-y) / {1+(1-x)*(1-y) }
                      -(1-x)*(1-y)           ≤      -x*y*(1-x)*(1-y) / {1+(1-x)*(1-y) }
                      -(1-x)*(1-y)           ≤ { -x*y-xy*(1-x)*(1-y)+xy } / {1+(1-x)*(1-y) }


                                                 54
                        -xy+x+y-1              ≤        x*y / {1+(1-x)*(1-y) } - x*y
                        x+y-1                  ≤        x*y / {1+(1-x)*(1-y) }
                        max[0,x+y-1]           ≤        x*y / {1+(1-x)*(1-y) }

5)    1                                        ≤        1+(1-x)*(1-y)
      1 / { 1+(1-x)*(1-y) }                    ≤        1
      x*y / { 1+(1-x)*(1-y) }                  ≤        x*y

6)    1-(1-x)*(1-y)                            ≤        1
      1                                        ≤        1 / {1-(1-x)*(1-y) }
      x*y                                      ≤        x*y / { 1-(1-x)*(1-y) }

7)    if x ≤ y
                 then
                        0                               ≤      x+(1-y)
                        0                               ≤      x-x*y
                        y                               ≤      x+y-x*y
                        y                               ≤      1-(1-x)*(1-y)
                        y / { 1-(1-x)*(1-y)}            ≤      1
                        x*y / { 1-(1-x)*(1-y) }         ≤      x
                        x*y / { 1-(1-x)*(1-y) }         ≤      min[x,y]
      if y ≤ x
                 then   interchange of names x ↔ y in above inequalities leads to the same
                        final result as the last inequality is invariant against such interchange

8)    min[x,y] ≤ max[x,y]

9)    if x ≤ y
                 then
                        0                      ≤        x*(1-y)2
                        0                      ≤        x*(1-2*y+y2)
                        0                      ≤        x-2*x*y+x*y2
                        y-x*y*y                ≤        x+y-2x*y
                        y*(1-x*y)              ≤        x+y-2x*y
                        y                      ≤        { x+y-2x*y }/ (1-x*y)
                        max[x,y]               ≤        { x+y-2x*y }/ (1-x*y)
                        max[x,y]               ≤        { (1-x*y)-(1-x)*(1-y) }/ (1-x*y)
                        max[x,y]               ≤        1 - (1-x)*(1-y) / (1-x*y)
      if y ≤ x
                 then   interchange of names x ↔ y in above inequalities leads to the same
                        final result as the last inequality is invariant against such interchange

10)   1                                        ≥        (1-x*y)
      1 / (1-x*y)                              ≥        1
      (1-x)*(1-y) / (1-x*y)                    ≥        (1-x)*(1-y)
      - (1-x)*(1-y) / (1-x*y)                  ≤        - (1-x)*(1-y)
      1 - (1-x)*(1-y) / (1-x*y)                ≤        1 - (1-x)*(1-y)



                                                   55
11)   1+x*y                                  ≥        1
      1                                      ≥        1 / (1+x*y)
      -1                                     ≤        -1 / (1+x*y)
      1 - (1-x)*(1-y)                        ≤        1 - (1-x)*(1-y) / (1+x*y)

12)   if x+y ≤ 1
              then
                        { x+y } / (1+x*y)                    ≤      x+y
                        {1+x*y-(1-x)*(1-y) } / (1+x*y)       ≤      x+y
                        1 - (1-x)*(1-y) / (1+x*y)            ≤      x+y
                        1 - (1-x)*(1-y) / (1+x*y)            ≤      min(1,x+y)

      if x+y>1
             then
                        1-y+y                                ≤      1
                        x*(1-y)+y                            ≤      1
                        x-x*y+y                              ≤      1
                        x+y                                  ≤      (1+xy)
                        { 1+x*y-(1-x)*(1-y) } / (1+x*y)      ≤      1
                        1 - (1-x)*(1-y) / (1+x*y)            ≤      1
                        1 - (1-x)*(1-y) / (1+x*y)            ≤      min(1,x+y)

13)   if x=0 then min(1,x+y) = y = max(x,y)
      if y=0 then similar;

14)   1≤1               is always true




                                                 56
6.1.2 Commutivity

Drastic product
       If max(x,y) < 1
              then T(x,y) = T(y,x) = 0
       If max(x,y) = 1
              then
                      if x =1 then T(x,y) = min(x,y) = min(1,y) =
                                       y = min(y,1) = min(y,x) = T(y,x)
                      if y = 1 similar

Limited difference
      T(x,y) = max(0,x+y-1) = max(0,y+x-1) = T(y,x)

Einstein product
       T(x,y) = x*y / [1+(1-x)*(1-y) ] = y*x / [1+(1-y)*(1-x) ] = T(y,x)

Algebraic product
      T(x,y) = x*y = y*x = T(y,x)

Hamacher product
     T(x,y) = x*y / [ 1-(1-x)*(1-y) ] = y*x / [ 1-(1-y)*(1-x) ] = T(y,x)

Minimum
     T(x,y) = min(x,y) = min(y,x) = T(y,x)

Maximum
     S(x,y) = max(x,y) = max(y,x) = S(y,x)

Hamacher sum
     S(x,y) = 1-[1-x]*[1-y] / [1-x*y] = 1-[1-y]*[1-x] / [1-y*x] = S(y,x)

Algebraic sum
      S(x,y) = 1 - [1-x]*[1-y] = 1 - [1-y]*[1-x] = S(y,x)

Einstein sum
       S(x,y) = 1-[1-x]*[1-y]/[1+x*y] = 1-[1-y]*[1-x]/[1+y*x] = S(y,x)

Limited sum
      S(x,y) = min(1,x+y) = min(1,y+x) = S(y,x)




                                              57
Drastic sum:
       if min(x,y) > 0
              then S(x,y) = S(y,x) = 1
       if min(x,y) = 0
              then
                       if x = 0 then S(x,y) = max(x,y) = max(0,y) =
                                      y = max(y,0) = max(y,x) = S(y,x)
                       if y = 0 similar

6.1.3 Associativity

We have to show                    T[T(x,y),z] = T[x,T(y,z)]

Drastic product

x        y        z        T(x,y)            T(y,z)            T[T(x,y),z] T[x,T(y,z)]
-------- ------------------------------------------------------------------------------------
0        0        0        0                 0                 0                0
0        0        r        0                 0                 0                0
0        0        1        0                 0                 0                0
0        r        0        0                 0                 0                0
0        r        r        0                 0                 0                0
0        r        1        0                 r                 0                0
0        1        0        0                 0                 0                0
0        1        r        0                 r                 0                0
0        1        1        0                 1                 0                0
r        0        0        0                 0                 0                0
r        0        r        0                 0                 0                0
r        0        1        0                 0                 0                0
r        r        0        0                 0                 0                0
r        r        r        0                 0                 0                0
r        r        1        0                 r                 0                0
r        1        0        r                 0                 0                0
r        1        r        r                 r                 0                0
r        1        1        r                 1                 r                r
1        0        0        0                 0                 0                0
1        0        r        0                 0                 0                0
1        0        1        0                 0                 0                0
1        r        0        r                 0                 0                0
1        r        r        r                 0                 0                0
1        r        1        r                 r                 r                r
1        1        0        1                 0                 0                0
1        1        r        1                 r                 r                r
1        1        1        1                 1                 1                1




                                                       58
Limited difference

       T[T(x,y),z] = max [ 0,T(x,y)+z-1 ] = max [ 0,max(0,x+y-1)+z-1 ] = max[0,x+y+z-2]
       T[x,T(y,z)] = max [ 0,x+T(y,z)-1 ] = max [ 0,x+max(0,y+z-1)-1 ] = max[0,x+y+z-2]

Einstein product

                              T(x,y) * z
T[T(x,y),z]           =       --------------------------
                              1 + {1-T(x,y) }*[1-z]

                              x*y / [1+(1-x)*(1-y) ] * z
                      =       -------------------------------------------                   (A)
                              1 + {1-xy / [ 1+(1-x)*(1-y) ] }*[1-z]

                              x*y*z
                      =       -----------------------------------------------------------
                               [ 1+(1-x)*(1-y) ] + { 1+(1-x)*(1-y)-x*y } * [1-z]

                              x*y*z
                      =       ------------------------------------
                              1+(1-x)*(1-y) + {2-x-y}*[1-z]

                              x*y*z
                      =       ----------------------------------------------
                              1+(1-x)*(1-y) + { (1-x)+(1-y) }*[1-z]

                              x*y*z
                      =       ---------------------------------------------------           (B)
                              1 + (1-x)*(1-y) + (1-y)*(1-z) + (1-z)*(1-x)

                              x * T(y,z)
T[x,T(y,z)]           =       -------------------------
                              1 + [1-x]*{ 1-T(y,z) }

                              x * y*z / [ 1+(1-y)*(1-z) ]
                      =       ---------------------------------------------
                              1 + [1-x]*{ 1-y*z / [ 1+(1-y)*(1-z) ] }

                               y*z / [ 1+(1-y)*(1-z) ] * x
                      =       ---------------------------------------------                 (C)
                              1 + { 1-y*z / [ 1+(1-y)*(1-z) ] }*[1-x]


 (C) results from (A) by cyclic interchanging x→y→z→x. Therefore continuation of the cal-
culation leads to a result similar to (B) also with cyclic interchange of variables. But as (B) is
invariant against such an interchange the prove is complete.



                                                 59
Algebraic product

T[T(x,y),z] = T(x,y)*z = x*y*z = x*T(y,z) = T[x,T(y,z)]

Hamacher product

                              T(x,y) * z
T[T(x,y),z]           =       --------------------------
                              1 - { 1-T(x,y) }*(1-z)

                              x*y / [ 1-(1-x)*(1-y) ] * z
                      =       -------------------------------------------                              (A)
                              1 - { 1-xy / [ 1-(1-x)*(1-y) ] }*(1-z)

                              x*y*z
                      =       --------------------------------------------------------
                              [ 1-(1-x)*(1-y) ] - { 1-(1-x)*(1-y)-x*y }*(1-z)

                              x*y*z
                      =       -------------------------------------
                              x+y-x*y - { x+y-2x*y }*(1-z)

                              x*y*z
                      =       -----------------------------                                            (B)
                              x*y+y*z+z*x-2*x*y*z

                              x*y*z
                      =       ----------------------------------------------------------------------
                              1-(1-x)*(1-y)-(1-y)*(1-z)-(1-z)*(1-x)+2*(1-x)*(1-y)*(1-z)

                              x * T(y,z)
T[x,T(y,z)]           =       --------------------------
                              1 - (1-x)*{ 1-T(y,z) }

                              x * y*z / [ 1-(1-y)*(1-z) ]
                      =       -------------------------------------------
                              1 - (1-x)*{1-y*z / [1-(1-y)*(1-z) ] }

                              y*z / [ 1-(1-y)*(1-z) ] * x
                      =       ---------------------------------------------                            (C)
                              1 - { 1-y*z / [ 1-(1-y)*(1-z) ] }*(1-x)


(C) results from (A) by cyclic interchanging x→y→z→x. Therefore continuation of the cal-
culation leads to a result similar to (B) also with cyclic interchange of variables. But as (B) is
invariant against such an interchange the prove is complete.




                                                 60
Minimum
T[T(x,y),z] = min[T(x,y),z] = min[min(x,y),z] = min[x,y,z] = min[x,min(y,z)] =
min[x,T(y,z)] = T[x,T(y,z)]

Maximum
S[S(x,y),z] = max[S(x,y),z] = max[max(x,y),z] = max[x,y,z] = max[x,max(y,z)] =
max[x,S(y,z)] = S[x,S(y,z)]

Hamacher sum

                                   [1- S(x,y)] * (1-z)
S[S(x,y),z]          =      1-     ----------------------
                                   1 - S(x,y) * z

                                    { 1-[ 1-(1-x)*(1-y) / (1-xy) ] } * (1-z)
                     =       1-      ---------------------------------------------   (A)
                                    1 - { 1-(1-x)*(1-y) / (1-x*y) } * z

                                    (1-x)*(1-y) / (1-x*y) * (1-z)
                     =      1-      --------------------------------------------
                                    1 - [ 1-x*y-(1-x)*(1-y) ] / (1-x*y) * z

                                    (1-x)*(1-y)*(1-z)
                     =       1-    --------------------------------------
                                   1-x*y - [ 1-x*y-(1-x)*(1-y) ] * z

                                     (1-x)*(1-y)*(1-z)
                     =      1-      --------------------------------------
                                    1-x*y - [ 1-x*y-1+x+y-x*y ] * z

                                    (1-x)*(1-y)*(1-z)
                     =      1-      -----------------------------                    (B)
                                    1-x*y-y*z-z*x+2*x*y*z

                                    (1-x) * [1- S(y,z)]
S[x,S(y,z)]          =      1-       ---------------------
                                    1 - x * S(y,z)

                                    (1-x) * { 1-[ 1-(1-y)*(1-z) / (1-y*z) ] }
                     =      1-      ----------------------------------------------
                                    1 - x * { 1-(1-y)*(1-z) / (1-y*z) }

                                    { 1-[ 1-(1-y)*(1-z) / (1-y*z) ] } * (1-x)
                     =      1-      ----------------------------------------------   (C)
                                    1 - { 1-(1-y)*(1-z) / (1-y*z) } * x




                                               61
(C) results from (A) by cyclic interchanging x→y→z→x. Therefore continuation of the cal-
culation leads to a result similar to (B) also with cyclic interchange of variables. But as (B) is
invariant against such an interchange the prove is complete.

Algebraic sum

S[S(x,y),z] = 1-{1-S(x,y)}*(1-z) = 1-{1-[ 1-(1-x)*(1-y) ] }*(1-z) = 1-(1-x)*(1-y)*(1-z)
S[x,S(y,z)] = 1-(1-x)*{1-S(y,z) } = 1-(1-x)*{ 1-[ 1-(1-y)*(1-z) ] }= 1-(1-x)*(1-y)*(1-z)

Einstein sun

S[S(x,y),z]           =       1-      { 1-S(x,y) }*(1-z) / { 1+S(x,y)*z }

                                      { 1 - [ 1-(1-x)*(1-y) / (1+x*y) ] } * (1-z)
                      =       1-      --------------------------------------------------
                                      1 + [ 1-(1-x)*( 1-y) / (1+x*y) ] * z

                                      (1-x)*( 1-y)/(1+x*y) * (1-z)
                      =       1-      -----------------------------------------------      (A)
                                      1 + [ 1+x*y-(1-x)*( 1-y) ] / (1+x*y) * z

                                      (1-x)*( 1-y)*( 1-z)
                      =       1-      -------------------------------------------
                                      1+x*y + [ 1+x*y-(1-x)*( 1-y) ] * z

                                      (1-x)*( 1-y)*( 1-z)
                      =       1-      -----------------------------------------
                                      1+x*y + [ 1+x*y-1+x+y-x*y ] * z

                                      (1-x)*( 1-y)*( 1-z)
                      =       1-      ------------------------
                                      1+x*y + [ x+y ] * z

                                      (1-x)*( 1-y)*( 1-z)
                      =       1-      ----------------------                               (B)
                                      1+x*y+yz+zx

S[ x,S(y,z) ] = 1 - (1-x)*{ 1-S(y,z) } / { 1+x*S(y,z) }

                                      (1-x) * { 1 - [ 1-(1-y)*( 1-z) / (1+yz) ] }
                      =       1-      ------------------------------------------------
                                      1 + x * [ 1-(1-y)*( 1-z) / (1+yz) ]

                                      (1-y)*( 1-z) / (1+yz) * (1-x)
                      =       1-      --------------------------------------------         (C)
                                      1 + [ 1+yz-(1-y)*( 1-z) ] / (1+yz) * x




                                                62
(C) results from (A) by cyclic interchanging x→y→z→x. Therefore continuation of the cal-
culation leads to a result similar to (B) also with cyclic interchange of variables. But as (B) is
invariant against such an interchange the prove is complete.

Limited sum

S[S(x,y),z] = min[ 1,S(x,y)+z ] = min[ 1,min(1,x+y)+z ] = min[ 1,x+y+z ]
S[x,S(y,z)] = min[ 1,x+S(y,z) ] = min[ 1,x+min(1,y+z) ] = min[ 1,x+y+z ]

Drastic sum
x        y        z        S(x,y)           S(y,z)            S[S(x,y),z]       S[x,S(y,z)]
--------------------------------------------------------------------------------------------
0        0        0        0                0                 0                 0
0        0        r        0                r                 r                 r
0        0        1        0                1                 1                 1
0        r        0        r                r                 r                 r
0        r        r        r                1                 1                 1
0        r        1        r                1                 1                 1
0        1        0        1                1                 1                 1
0        1        r        1                1                 1                 1
0        1        1        1                1                 1                 1
r        0        0        r                0                 r                 r
r        0        r        r                r                 1                 1
r        0        1        r                1                 1                 1
r        r        0        1                r                 1                 1
r        r        r        1                1                 1                 1
r        r        1        1                1                 1                 1
r        1        0        1                1                 1                 1
r        1        r        1                1                 1                 1
r        1        1        1                1                 1                 1
1        0        0        1                0                 1                 1
1        0        r        1                r                 1                 1
1        0        1        1                1                 1                 1
1        r        0        1                r                 1                 1
1        r        r        1                1                 1                 1
1        r        1        1                1                 1                 1
1        1        0        1                1                 1                 1
1        1        r        1                1                 1                 1
1        1        1        1                1                 1                 1




                                                      63
6.1.4 Monotony
Assume 0≤x≤u≤1, 0≤y≤v≤1

Drastic product

T(x,y) = 0             if max(x,y)<1
       = min(x,y)      if max(x,y)=1

If max(u,v) <1 then max(x,y) < 1 hence T(x,y) = 0 and T(u,v) = 0
If max(u,v) = 1 and max(x,y) < 1 then T(x,y) = 0 ≤ min(u,v) = T(u,v)
If max(u,v) = 1 and max(x,y) = 1 then T(x,y) = min(x,y) ≤ min(u,v) = T(u,v)

Limited difference

T(x,y) = max(0,x+y-1) ≤ max(0,u+v-1) = T(u,v)

Algebraic product

T(x,y) = x*y ≤ u*v = T(u,v)

Hamacher product

T(x,y) = x*y / [1-(1-x)*(1-y) ]

dT(x,y) / dx           =      { y*[ 1-(1-x)*( 1-y) ] - (1-y)*x*y } / N2
                       =      { y*(x+y-x*y) -x*y + x*y2 } / N2
                       =      { x*y+y2-x*y2-x*y + x*y2 } / N2
                       =      y2 / N2
                       ≥0
dT(x,y)/dy             =      { x*[ 1-(1-x)*( 1-y) ] - (1-x)*x*y } / N2
                       =      { x*(x+y-x*y)-x*y + x2y } / N2
                       =      { x2+x*y-x2y-x*y + x2y } / N2
                       =      x2 / N2
                       ≥0

Minimum

T(x,y)=min(x,y) ≤ min(u,v)=T(u,v)

Maximum

S(x,y)=max(x,y) ≤ max(u,v)=S(u,v)

Hamacher sum

S(x,y) = 1 - (1-x)*( 1-y) / (1-x*y)




                                               64
dS(x,y)/dx             =      - [ -(1-y)*( 1-x*y) + y(1-x)*( 1-y) ] / N2
                       =      - [ -1+y+x*y-x*y2 + y-x*y-y2+x*y2 ] / N2
                       =      - [ -1+2*y-y2 ] / N2
                       =      (1-2*y+y2) / N2
                       =      (1-y)2 / N2
                       ≥0
dS(x,y)/dy             =      - [ -(1-x)*( 1-x*y)+x(1-x)*( 1-y) ] / N2
                       =      - [ -1+x+x*y-x2y +x-x2-x*y+x2y ] / N2
                       =      - [ -1+2*x-x2 ] / N2
                       =      (1-2*x+x2) / N2
                       =      (1-x)2 / N2
                       ≥0


Algebraic sum

S(x,y) = 1-(1-x)*(1-y) ≤ 1-(1-u)*(1-v) = S(u,v)

Limited sum

S(x,y) = min(1,x+y) ≤ min(1,u+v) = S(u,v)

Drastic sum

S(x,y) = 1             if min(x,y) > 0
        = max(x,y)     if min(x,y) = 0

If     0<min(x,y) ≤min(u,v)              then   S(x,y) = 1 = S(u,v)
If     0=min(x,y)<min(u,v)               then   S(x,y) = max(x,y) ≤ 1 = S(u,v)
If     0=min(x,y)=min(u,v)               then   S(x,y) = max(x,y) ≤ max(u,v) = S(u,v)


6.1.5 De-Morgan Equations
We have to show

1.) T(x,y) = 1 - S(1-x,1-y)
2.) S(x,y) = 1 - T(1-x,1-y)

Drastic product / Drastic sum

T(x,y) = 0                    falls max[x,y]< 1
       = min [x,y]            falls max[x,y] = 1
S(x,y) =1                     falls min[x,y]> 0
       = max[x,y]             falls min[x,y] == 0

If max(x,y) < 1
       then min(1-x,1-y) > 0
               hence T(x,y) = 0 and S(1-x,1-y) = 1
               hence T(x,y) = 0 = 1 - 1 = 1 - S(1-x,1-y)


                                                 65
If max(x,y) = 1
       then min(1-x,1-y) = 0
               if x=1 then 1-x=0
                      hence T(x,y) = y and S(1-x,1-y) = 1-y
                      hence T(x,y) = y = 1- (1-y) = 1 - S(1-x,1-y)
               if y=1 similar

If min(x,y) > 0
        then max(1-x,1-y) < 1
               hence S(x,y) = 1 and T(1-x,1-y) = 0
               hence S(x,y) = 1 = 1 - 0 = 1 - T(1-x,1-y)
If min(x,y) = 0
       then max(1-x,1-y) = 1
               if x=0 then 1-x=1
                      hence S(x,y) = y and T(1-x,1-y) = 1-y
                      hence S(x,y) = y = 1- (1-y) = 1 - T(1-x,1-y)
               if y=1 similar

Limited sum / Limited difference

T(x,y) =
S(x,y) = min (1,x+y )

If x+y≤1
       then 2 - (x+y) ≥1
              hence T(x,y) = max (0,x+y-1 ) = 0
                      S(1-x,1-y) = min[1,(1-x)+(1-y)] = min[1, 2-(x+y)] = 1
              hence T(x,y) = 0 = 1-1 = 1- S(1-x,1-y)
If x+y>1
       then 2 - (x+y) < 1
              hence T(x,y) = max (0,x+y-1 ) = x+y-1
                      S(1-x,1-y) = min[1,(1-x)+(1-y)] = min[1, 2-(x+y)] = 2-(x+y)
              hence T(x,y) = x+y-1 = 1-[ 2-(x+y) ] = 1- S(1-x,1-y)
If x+y≤1
       then 1 - (x+y) ≥0
              hence S(x,y) = min (1,x+y ) = x+y
                      T(1-x,1-y) = max[ 0, (1-x)+(1-y)-1 ] = max[ 0, 1-(x+y) ] = 1-(x+y)
              hence S(x,y) = x+y = 1-[ 1-(x+y) ] = 1- T(1-x,1-y)
If x+y>1
       then 1 - (x+y) < 0
              hence S(x,y) = min (1,x+y ) = 1
                      T(1-x,1-y) = max [0,(1-x)+(1-y)-1] = max[0, 1-(x+y)] = 0
              hence S(x,y) = 1 = 1-0 = 1 = 1- T(1-x,1-y)




                                              66
Einstein product / Einstein sum

x*y / [ 1+(1-x)*(1-y) ]
= 1 - [ 1-x]*[1-y] / [1+x*y]

x*y / [ 1+(1-x)*( 1-y) ]       =        x*y / [ 1+(1-x)*( 1-y) ]
x*y / [ 1+(1-x)*( 1-y) ]       =        1 - { 1-x*y / [ 1+(1-x)*( 1-y) ] }
x*y / [ 1+(1-x)*( 1-y) ]       =        1 - { 1-[1-(1-x)]*[1-(1-y)] / [ 1+(1-x)*( 1-y) ] }
T(x,y)                         =        1 - S(1-x,1-y)

1 - (1-x)*(1-y) / ( 1+x*y )    =        1-(1-x)*(1-y) / ( 1+x*y )
1 - (1-x)*(1-y) / ( 1+x*y )    =        1-(1-x)*(1-y) / {1+[ 1-(1-x) ]*[ 1-(1-y) ] }

Algebraic product / Algebraic sum

T(x,y) = x*y
S(x,y) = 1 - [1-x]*[1-y]

x*y                     =      1 - (1 - x*y)
x*y                     =      1 - { 1 - [ 1-(1-x) ]*[ 1-(1-y) ] }
T(x,y)                  =      1 - S(1-x,1-y)

1-(1-x)*(1-y)           =      1 - (1-x)*(1-y)
S(x,y) =                =      1 - T(1-x,1-y)

Hamacher product / Hamacher sum

T(x,y) = x*y / [ 1-(1-x)*(1-y) ]
S(x,y) = 1 - (1-x)*[ (1-y] / [1-x*y ]

xy / [ 1-(1-x)(1-y) ]          =        xy / [ 1-(1-x)*(1-y) ]
xy / [ 1-(1-x)(1-y) ]          =        1 - { 1-[ 1-(1-x) ]*[ 1-(1-y) ] / [ 1-(1-x)*(1-y) ] }
T(x,y)                         =        1 - S(1-x,1-y)

(1-x)*(1-y) / (1-x*y)          =        (1-x)*(1-y) / (1-x*y)
1 - (1-x)*(1-y) / (1-x*y)      =        1 - (1-x)*(1-y) / { 1-[1 -(1-x) ]*[ 1-(1-y) ] }
S(x,y)                         =        1 - T(1-x,1-y)

Minimum / Maximum

T(x,y) = min(x,y)
S(x,y) = max(x,y)

If x≤y
        then 1-x ≥ 1-y
               hence T(x,y) = min(x,y) = x
                       S(1-x,1-y) = max(1-x,1-y) = 1-x
               hence T(x,y) = x = 1 - (1-x) = 1 - S(1-x,1-y)
If x>y then similar


                                                 67
6.1.6 Special values of scalable functions

6.1.6.1 Hamacher intersection
P(x,y) = x*y / [ α -(α -1)*(x+y-x*y) ]

α=0
P(x,y) = x*y / (x+y-x*y) = x*y / [ 1-(1-x)*(1-y) ]           Hamacher product

α=1
P(x,y) = x*y                                                 Algebraic product

α=2
P(x,y) = x*y / [ 2-(x+y-x*y) ] = x*y / [ 1+(1-x)*(1-y) ]     Einstein product

α=∞
If max(x,y)<1
       then x+y-x*y<1
       hence
              x+y-x*y = 1-z with z>0
              P(x,y) = x*y / [ α -(α -1)*(1-z) ] = x*y / ( α - α +1+ α *z-z) = x*y / (1+ α* z-z)
              P(x,y)→0 for α→∞ because z>0
If max(x,y)=1
       then
              if x=1 then P(x,y) = y / [ α -( α -1) ] = y
              if y=1 then P(x,y) = x / [ α -( α -1) ] = x

Summary:
lim P(x,y) = 0        for α→∞        if max(x,y)<1
lim P(x,y) = min(x,y) for α→∞        if max(x,y)=1


6.1.6.2 Hamacher junction
Q(x,y) = [ (α -1)*x*y+x+y ] / (1+ α*x*y)

α =-1
Q(x,y) = (-2*x*y+x+y) / (1-x*y) = [ 1-x*y-(1-x)*(1-y) ] / (1-x*y)
        = 1- [ (1-x)*(1-y) ] / (1-x*y)                            Hamacher sum

α =0
Q(x,y) = -x*y+x+y = 1-(1-x)*(1-y)                                   Algebraic sum

α =1
Q(x,y) = (x+y) / (1+x*y) = [ 1+x*y-(1-x)*(1-y) ] / (1-x*y)
        = 1- [ (1-x)*(1-y) ] / (1+x*y)                              Einstein sum




                                               68
α →∞
If min(x,y)>0
       then xy>0,   Q(x,y) → (α*x*y) / (α*x*y) = 1
If min(x,y)=0
       then xy=0, Q(x,y) = x+y = max(x,y)

Summary:
lim Q(x,y) = 1       for α→∞     if min(x,y)>0
lim Q(x,y) = max(x,y)      for α→∞      if min(x,y)=0


6.1.6.3 Yager intersection
                    α          α        α
P(x,y) = 1 - min{1, √[(1-x) + (1-y) ]}

α =1
P(x,y) = 1 - min {1,(1-x)+(1-y) } = max(0,x+y-1)             Limited difference

α→∞
If x>y then (1-x)<(1-y)
                                 α         α
        hence P(x,y) → 1-min{1, √ (1-y) } = 1-min(1,1-y) = y = min(x,y)
If x<y then (1-x)>(1-y)
                                 α      α
        hence P(x,y) → 1-min{1, √(1-x) ] } = 1-min(1,1-x) = x = min(x,y)
                               α         α                α
If x=y then P(x,y) = 1 - min{1, √2*(1-x) ] } = 1 - min{1, √2*(1-x) }
        hence P(x,y) → 1 - min{ 1,1*(1-x) } = 1-(1-x) = x = min(x,y)
Summary:
lim P(x,y) = min(x,y)             for α→∞                    Minimum



6.1.6.4 Yager junction
                α       α     α
Q(x,y) = min{1, √[x         + y ]}

α =1
Q(x,y) = min(1,x+y)                                          Limited sum

α→∞
                           α   α
If x>y then Q(x,y) → min{1, √[x ]} = min(1,x) = x = max(x,y)
                           α   α
If x<y then Q(x,y) → min{1, √[y ] } = min(1,y) = y = max(x,y)
                           α     α           α
If x=y then Q(x,y) = min{1, √[2*x ]} = min{1, √2*x} → min(1,x) = x = max(x,y)

Summary:
lim Q(x,y) = max(x,y)             for α→∞                    Maximum




                                            69
Index of content

FUZZY LOGIC BASIC CONCEPTS AND APPLICATIONS............................................0

1      INTRODUCTION ............................................................................................................1
    1.1 WHY FUZZY CONTROL SYSTEMS ?....................................................................................1
    1.2 HISTORY ..........................................................................................................................1
2      ENTITIES, VALUES, MEMBER FUNCTION.............................................................3
    2.1 ABSTRACT ENTITIES, BASE VALUES, FUZZY VALUES ........................................................3
    2.2 MEMBER FUNCTION .........................................................................................................5
       2.2.1      Definition and meaning ..................................................................................................... 5
       2.2.2      Common representations ................................................................................................... 7
    2.3    FUZZY NUMBERS ............................................................................................................11
    2.4    FUZZY INTERVALS / FUZZY FLAT NUMBERS ...................................................................12
    2.5    FUZZY SETS ....................................................................................................................12
    2.6    GENERALIZED FUZZY SETS .............................................................................................13
3      OPERATIONS WITH FUZZY SETS ..........................................................................15
    3.1    COMPLEMENT SET / NOT...............................................................................................15
    3.2    INTERSECTION / AND ....................................................................................................16
    3.3    JUNCTION / OR ..............................................................................................................18
    3.4    MORE GENERAL DEFINITIONS.........................................................................................20
    3.5    COMMON PROPERTIES OF T-NORM FUNCTIONS AND S-NORM FUNCTIONS .....................21
    3.6    ADDITIONAL FORMULA ..................................................................................................23
    3.7    NUMERIC EXAMPLE........................................................................................................24
    3.8    CONNECTING A FUZZY SET TO ITSELF.............................................................................25
       3.8.1      Intersection ...................................................................................................................... 25
       3.8.2      Junction............................................................................................................................ 26
    3.9 CONNECTING A FUZZY SET TO ITS COMPLEMENT SET .....................................................26
       3.9.1      Intersection ...................................................................................................................... 26
       3.9.2      Junction............................................................................................................................ 27
    3.10       SCALABLE TRIANGULAR FUNCTIONS ..........................................................................27
    3.11       SET PRODUCT / TWO-DIMENSIONAL MEMBER FUNCTIONS ..........................................28
       3.11.1 General definitions .......................................................................................................... 28
       3.11.2 Projections of two-dimensional member functions.......................................................... 29
       3.11.3 Two-dimensional fuzzy sets.............................................................................................. 29
    3.12       MULTI DIMENSIONAL MEMBER FUNCTIONS ................................................................30
       3.12.1 Definition ......................................................................................................................... 30
       3.12.2 Projections....................................................................................................................... 30
       3.12.3 Fuzzy sets ......................................................................................................................... 30
    3.13       EXAMPLE ...................................................................................................................31
4      FUZZY CONTROLLERS .............................................................................................35
    4.1 INTRODUCTION ..............................................................................................................35
    4.2 RULES, IMPLICATIONS, CONCLUSIONS ...........................................................................37
       4.2.1      Rules ................................................................................................................................ 37
       4.2.2      Implications ..................................................................................................................... 39


                                                                          70
       4.2.3      Combination of process states and rules ........................................................................ 39
       4.2.4      How to select a sharp value of control variable B........................................................... 40
       4.2.5      Details.............................................................................................................................. 40
       4.2.6      Two examples................................................................................................................... 41
       4.2.7      Final modification ........................................................................................................... 42
       4.2.8      Combined preconditions .................................................................................................. 43
    4.3 ACCUMULATION AND DE-FUZZIFICATION .....................................................................43
       4.3.1      Several simultaneous rules .............................................................................................. 43
       4.3.2      De-Fuzzification .............................................................................................................. 44
5      FUZZY NUMBERS AND FUZZY INTERVALLS.....................................................46
    5.1 PROBLEM .......................................................................................................................46
    5.2 RELATIONS ....................................................................................................................46
       5.2.1      One independent variable................................................................................................ 46
       5.2.2      Several independant variables......................................................................................... 49
6      APPENDIX......................................................................................................................54
    6.1 PROOFS OF COMMON PROPERTIES ..................................................................................54
       6.1.1      Sequence of magnitude .................................................................................................... 54
       6.1.2      Commutivity..................................................................................................................... 57
       6.1.3      Associativity..................................................................................................................... 58
       6.1.4      Monotony ......................................................................................................................... 64
       6.1.5      De-Morgan Equations ..................................................................................................... 65
       6.1.6      Special values of scalable functions ................................................................................ 68




                                                                         71
Index of tables
Table 1 ........................................................................................................................................6
Table 2 ........................................................................................................................................6
Table 3 ........................................................................................................................................7
Table 4 ......................................................................................................................................13
Table 5 Some T-Norm functions ............................................................................................21
Table 6 Some S-Norm functions.............................................................................................21
Table 7 Pairs of Norm and Co-Norm functions.....................................................................22
Table 8 Membership functions of fuzzy set intersection with itself......................................25
Table 9 Membership functions of fuzzy set junction with itself ...........................................26
Table 10 Membership functions of fuzzy set intersection with complement set...................27
Table 11 Membership functions of fuzzy set junction complement set ................................27
Table 12 Membership functions p(a,f) of temperature and q(b,g) of pressure; Fuzzy sets P(f)
    of temperature and Q(g) of pressure ...............................................................................31
Table 13 Two-dimensional fuzzy values with _AND_ respective _OR_ connection ..........32
Table 14 Partial two-dimensional membership function µ(a,b,warm_AND_high) = min[
    p(a,warm), q(b,high) ].......................................................................................................32
Table 15 Partial two-dimensional membership function µ(a,b,hot_OR_low) = max [
    p(a,hot),q(b,low) ] .............................................................................................................33
Table 16 Projection ν(a,f) of two-dimensional membership function µ(a,b,f_AND_g) on value
    pair b = b0 = 6*105Pa (sharp) and g = g0 = "high" (fuzzy) of abstract entity pressure
    ν(a,f) = µ( a, 6, f_AND_high ) = min[ p(a,f), q(6,high) ] = min [ p(a,f), 0.75 ] ............33
Table 17 Projection ν(a,f) of two-dimensional membership function µ(a,b,f_OR_g) on value
    pair b = b0 = 6*105Pa (sharp) and g = g0 = "high" (fuzzy) of abstract entity pressure.
    ν(a,f) = µ( a, 6, f_OR_high ) = max[ p(a,f), q(6,high) ] = max [ p(a,f), 0.75 ] ................34
Table 18 Truth table of boolean functions f0 → g0 and (⌐f0) ⋁g0 .........................................39
Table 19 ....................................................................................................................................42
Table 20 Example of a relation...............................................................................................48
Table 21 Example of a relation (continued) ...........................................................................48
Table 22 Products w0 = x0*y0 and memberships r(w0) .........................................................51
Table 23 Membership p(w0, about_3.4 * about_5.9 ).............................................................52
Table 24 Membership p(w0, about_3.4 * about_5.9 ), continued...........................................52




                                                                      72

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:928
posted:10/22/2007
language:English
pages:73
Masoud Mashhadi Masoud Mashhadi
About