Intuitionistic fuzzy control language
Author: Dmitry Kazakov
Description: Intuitionistic extension of fuzzy control language
Keywords: fuzzy, fuzzy control, intuitionistc fuzzy set, Ada, Ada 95

FUZZY MACHINE LEARNING FRAMEWORK |  | by Dmitry A. Kazakov (mailbox@dmitry-kazakov.de) |  | Fuzzy Control Language
an intuitionistic extension
with fuzzy graph-schemes | version 1.0

Fuzzy machine learning framework downloading page

## 1. Introduction

The Fuzzy Control Language (FCL) is a draft IEC 1131 standard for programmable controllers. IFCL is a version of FCL extended with the following goals in mind:

- Full support of intuitionistic fuzzy sets as an extension of plain fuzzy sets on the case of incomplete and contradictory data. Intuitionistic fuzzy sets natively express the measurement errors as found in physical systems;
- Integrated support of dimensioned values in SI (Le Système International d'Unités) unit system. Support for irregular dimension units and ones outside SI;
- The language should represent a fully functional consistent subset of FCL as specified in the draft.

A program sample:

`function_block Test var_input Light : Real [lux]; end_var var_output Switch : Nominal (On, Off); end_var fuzzify Light term Dark := ( 100 lux, 1)( 1000 lux, 0); term Twilight := ( 500 lux, 0)( 1000 lux, 1)(15000 lux, 1)(20000 lux, 0); term Bright := (10000 lux, 0)(20000 lux, 1); end_fuzzify ruleblock Rules if Light is Dark then Switch is On; if Light is Bright then Switch is Off; end_ruleblock end_function_block`

## 2. Lexical elements

In this document the characters of the source code referred in syntax rules are printed in courier red. Syntax rules are expressed in Bacus-Naur forms (BNF) The operations of the forms are printed in courier bold. Literal elements are printed in bold red. Identifiers are put in angular brackets. The BNF operations are denoted as follows:

> `::=` | -- definition
> `[]` | -- optional element
> `|` | -- alternation
> `{}` | -- required element
> `(*` | -- this is a literal element

### 2.1. Character set

An IFCL program is written using the Unicode character set (see Unicode Transformation Format). The characters space (SP), tabulation (HT), line tabulation (VT), carriage return (CR), line feed (LF), and form feed (FF) are considered blank. Line end is determined by the operating system.

All lexical elements except for string and character literals are case-insensitive. The case is defined by the categories letter, upper case (Lu) and letter, lower case (Li) in the file UnicodeData.txt.

Any IFCL program can be written using only the code positions 0..127 corresponding to ASCII code.

### 2.2. Comments

There are two types of comments. Comments starting with `(*` continue until first appearance of `*)`. Nested appearances of `(*` are not recognized. Comments starting with `--` continue to the end of the source line they appear. Examples of comments:

> `-- This comment continues to the line end`
> `(* Comments like this may`
> `span across several lines *)`

### 2.3. Literals

#### 2.3.1. Integer literals

Integer literals have the syntax:

> `<integer>` | `::=` | `<decimal-integer> | <based-integer>`
> `<decimal-integer>` | `::=` | `<decimal-numeral>[<exponent>]`
> `<based-integer>` | `::=` | `<base>#<based-numeral>#[<exponent>]`
> `<decimal-numeral>` | `::=` | `<decimal-digit>[[_]<decimal-numeral>]`
> `<decimal-digit>` | `::=` | `0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9`
> `<exponent>` | `::=` | `E [<sign>]<decimal-numeral>`
> `<sign>` | `::=` | `+ | -`
> `<based-numeral>` | `::=` | `<based-digit>[[_]<based-numeral>]`
> `<based-digit>` | `::=` | `<decimal-digit> | A | B | C | D | E | F`
> `<base>` | `::=` | `<decimal-numeral>`

Within an integer literal underline (`_`) can be used to separate digits for better readability. Underline is not allowed to follow another underline start or end a numeral. `<base>` shall denote a number 2..16. When exponent appears it must be non-negative. No blank characters or comments are allowed in an integer literal. Examples of legal integer literals:

> `123` | – | Decimal number 12310
> `1A6#FF#` | – | Hexadecimal number 1A616=42210
> `2#100_000_000#` | – | Binary number 1000000002=25610
> `1e6` | – | Decimal number 100000010

Integer literals are overloaded. They have either the type Integer or the type Truth_Value. In the latter case the only valid values are 0, which represents logical false, and 1 which does logical true.

#### 2.3.2. Real literals

Real literals have the syntax:

> `<real>` | `::=` | `<decimal-real> | <based-real>`
> `<decimal-real>` | `::=` | `<decimal-numeral>.<decimal-numeral>[<exponent>]`
> `<based-real>` | `::=` | `<base>#<based-numeral>.<based-numeral>#[<exponent>]`

No blank characters or comments are allowed in a real literal. Examples of legal real literals:

> `123.0` | – | Decimal number 123.010
> `1E-1` | – | Decimal number 0.110
> `2#111.111#E2` | – | Binary number 11111.12=31.510

Real literals are overloaded. They have either the type Real or the type Truth_Value. In the latter case the only valid values are ones from the interval [0,1]. The value 0.0 represent logical false. The value 1.0 represents logical true.

#### 2.3.3. Dimensioned literals

Dimensioned literals have the syntax:

> `<dimensioned-real>` | `::=` | `[<integer> | <real>] <dimension>`
> `<dimension>` | `::=` | Dimension specification

When a value appear it must be separated from the dimension by at least one blank character or comment when the dimension begins with a `<letter>`. The dimension syntax is described in Measures_UTF8_Edit.Get_Unit. Examples of legal dimensioned literals:

> `5 m` | – | 5 meter
> `14.01°C` | – | 287.16 K (14.01 Celsius degree)
> `0.123 μPa` | – | 0.123E-6 Pa
> `foot` | – | 0.3048000 meter

Dimensioned literals have the type Real.

#### 2.3.4. Truth values

Intutionistic truth literals have the syntax:

> `<intuitionistic-truth-value>` | `::=` | `[<possibility>:<necessity>] | ⊤ | ⊥`
> `<possibility>` | `::=` | `<real> | <integer>`
> `<necessity>` | `::=` | `<real> | <integer>`

Here `<possibility>` and `<necessity>` shall be numbers in the range [0,1]. Blank characters and comments may surround the brackets (`[]`) and colon (`:`). `⊤` (the Unicode code point 22A416) represents fully contradictory truth value. `⊥` (the Unicode code point 22A516) represents fully uncertain truth value. Examples of legal intuitionistic truth values:

> `[1:1]` | – | True
> `[0:0]` | – | False
> `[0.9:0.5]` | – | Possibility is 0.9, necessity is 0.5
> `[1:0]` | – | Uncertain
> `⊥` | – | Same as above
> `[0:1]` | – | Contradictory
> `⊤` | – | Same as above

Intuitionistic truth value literals have the type Intuitionistic_Truth_Value.

#### 2.3.5. String and character literals

String and character literals have the syntax:

> `<character>` | `::=` | `''' | '<non-quotation-mark>'`
> `<string>` | `::=` | `"<string-body>" | ""`
> `<string-body>` | `::=` | `{"" | <non-quotation-mark>} [<string-body>]`
> `<non-quotation-mark>` | `::=` | Any Unicode code position except "

Within string literal quotation marks are doubled. Examples of legal character and string literals:

> `'''` | – | Character '
> `"abcd"` | – | String abcd
> `""""` | – | String "
> `""` | – | Empty string

### 2.4. Identifiers

Identifiers start with a `<letter>` and can contain digits and underline character:

> `<identifier>` | `::=` | `{<decimal-digit> | <letter>}[_]<identifier>`
> `<letter>` | `::=` | The Unicode character in the categories uppercase or lowercase letters

In the above specification of `<letter>` the categories letter, upper case (Lu) and letter, lower case (Li) are determined by the file UnicodeData.txt. Identifiers are case insensitive.

Identifiers can refer predicate variables and domain values of nominal and linguistic set predicate variables.

## 3. Types

The language objects are subdivided into:

- Constants
- Variable predicates
- Predicates

### 3.1. Types of constants

The language defines the following types of constants:

Types of constants | Example | Description
Numeric types |  | Numeric types with the operations `+`, `-`, `*`, `/` etc
| Integer | `123` | Integer values
Real | `14.01°C` | Dimensioned real values
String types |  | Characters and strings
| Character | `'x'` | Character values
String | `"abdcd"` | String values
Lattice types |  | Types with the operations `and`, `or`, `xor`, `not`
| Fuzzy lattice types |  | Lattices with the law of excluded middle on any measurable subset
| Logical |  | Logical values
| Truth_Value | `0.5` | Fuzzy truth values from [0,1]
Sets |  | Fuzzy subsets
| Singletons |  | Fuzzy singleton sets
| Integer_Singleton | `(5,1)` | Integer singleton
Real_Singleton | `(5.2 m, 0.5)` | Dimensioned real singleton
Ranges |  | Range subsets
| Integer_Range | `1..20` | Integer range
Real_Range | `1 m..20 m` | Dimensioned real range
Subsets |  | Free subsets
| Integer_Set | `1..3 ⋃ 7` | Integer subset
Real_Set | `(5,0)(7,1)[kPa]` | Dimensioned real subset
Domain_Subset | `low..high` | Fuzzy subset of the domain set of a variable
Intuitionistic lattice types |  | Lattices with no law of excluded middle
| Logical |  | Intuitionistic logical values
| Intuitionistic_Truth_Value | `[1:0.5]` | Intuitionistic truth values from [0,1]×[0,1]
Sets |  | Intuitionistic subsets
| Intuitionistic_Domain_Subset | `low^[1:0.5] ⋃ high` | Intuitionistic subset of the domain set of a variable

### 3.2. Types of predicate variables

Predicate variables are subdivided into input predicate variables, those for which values are known from the rules base, and the output predicate variables estimated from the values of the input ones and the rules. Further predicate variables are separated according to the type of the domain set:

Types of predicate variables | Description
Nominal predicate variables | The predicate variables with a non-numeric discrete domain
| Enumeration predicate variables | The domain set consists of nominal values specified by identifiers
Numeric predicate variables | The predicate variables with a numeric domain
| Discrete numeric predicate variables | The predicate variables with a discrete numeric domain
| Integer predicate variables | The domain set consists of a finite range of integer numbers
Continuous numeric predicate variables | The predicate variables with a continuous numeric domain
| Float predicate variables | The domain set consists of a finite set of intervals overlapping in the end points
Linguistic set predicate variables | The domain set consists of a finite set of linguistic variables

#### 3.2.1. Declaration of predicate variables

Predicate variables are declared in one or more declaration blocks:

> `<input-variables-block>` | `::=` | `var_input <variable-declarations-list> end_var`
> `<output-variables-block>` | `::=` | `var_output <variable-declarations-list> end_var`
> `<variable-declarations-list>` | `::=` | `<variable-declaration>[<variable-declarations-list>]`
> `<variable-declaration>` | `::=` | `<identifier>:<variable-type-definition>;`
> `<variable-type-definition>` | `::=` | `{` | `<nominal-variable>`
> |  | `|` | `<integer-variable>`
> |  | `|` | `<float-variable>`
> |  | `|` | `<linguistic-set-variable>`
> |  | `}` |

Each variable has a unique name specified by the `<identifier>`, which is followed by colon (`:`), declaration of the type and finished by semicolon (`;`).

#### 3.2.2. Nominal predicate variables

A nominal variable has the domain specified as a set of identifiers:

> `<nominal-variable>` | `::=` | `nominal (<nominal-domain>)`
> `<nominal-domain>` | `::=` | `<identifier>[,<nominal-domain>]`

Example of a nominal variable declaration:

> `Color : nominal (Red, Green, Blue);`

#### 3.2.3. Integer variables

An integer variable has the domain consisting of a range of integer numbers:

> `<integer-variable>` | `::=` | `integer <integer-range>`

Here `<integer-range>` is an expression resolving to a range of integer numbers. The following is an example of a valid integer variable declaration:

> `Dozen : integer 1..1+11;` | – | Range 1 to 12

#### 3.2.4. Float variables

A float variable's domain consists of dimensioned intervals. Intervals intersect in their end points.

> `<float-variable>` | `::=` | `float [[<dimension>]] <cardinality> range <float-range>`

Here `<dimension>` specifies the measurement units of the domain values. `<cardinality>` is an expression resolving to positive integer number that specifies the number of intervals the domain set consists of. `<float-range>` is the domain set. It shall resolve to a range of real numbers. When the result is dimensionless the range bounds are assumed to be specified in the units of the variable dimension. Otherwise the dimension specified shall be compatible with one of the variable. The following are examples of a valid declarations:

> `Temperature : float [°C] 10 range -10..120;`

The variable Temperature is measured in °C, it has the domain set -10°C..120°C split into 10 intervals.

> `Velocity : float [m/s] 5 range 0..20 [mph];`

The variable Velocity is measured in m/s, it has the domain set 0..8.938888 m/s in 5 intervals.

#### 3.2.5. Linguistic set variables

A linguistic set variable has a dimensioned domain represented by a set of linguistic terms. Each linguistic term, also called linguistic variable, is a fuzzy subset of the domain.

> `<linguistic-set-variable>` | `::=` | `real [[<dimension>]]`

`<dimension>` specifies the measurement units of the domain values. Examples of valid linguistic set variables declarations:

> `Angle : real;`
> `Power : real [W];`

The terms of an input linguistic set variable are declared in a fuzzify block:

> `<fuzzify-block>` | `::=` | `fuzzify <identifier>`
> |  | `` | `<linguistic-set>`
> |  | `end_fuzzify`
> `<linguistic-set>` | `::=` | `<linguistic-term>; [<linguistic-set>]`
> `<linguistic-term>` | `::=` | `term <identifier> := <domain-set>`

Here `<identifier>` following the keyword `fuzzify` is the name of the input linguistic set variable being which linguistic terms are being defined. Only one block is allowed per variable. `<identifier>` following the keyword `term` specifies the name of the term. This name can appear where a variable subset is expected. `<domain-set>` shall resolve either to a real subset or to a real value. The given dimension shall be compatible with one of the variable. The following example illustrates definition of the linguistic terms for the variable T declared as:

> `T : real [°C];` |

Linguistic terms:

> `fuzzify T`
> `` `term Chill := (-10,1)(-4,0); -- °C is assumed`
> `term Cold := ( 11,1)(17,0) [°C];`
> `term Tepid := ( 3, 0)( 8,1)(21,1)(28,0) [°C];`
> `term Warm := ( 15,0)(21,1)(29,1)(35,0) [°C];`
> `end_fuzzify`

The terms of an output: linguistic set variable are declared in a defuzzify block:

> `<defuzzify-block>` | `::=` | `defuzzify <identifier>`
> |  |  | `<output-linguistic-set>`
> |  | `end_defuzzify`
> `<output-linguistic-set>` | `::=` | `{` | `<linguistic-term>`
> |  | `|` | `method : <defuzzify-method>`
> |  | `|` | `default := <domain-value>`
> |  | `|` | `accu : <method>`
> |  | `};` | `[<output-linguistic-set>]`
> `<defuzzify-method>` | `::=` | `{ coa | cog | cogs | lm | rm }`

Here `<identifier>` following the keyword `defuzzify` is the name of the output linguistic set variable. Only one block is allowed per variable. `<identifier>` following the keyword `term` specifies the name of the term. This name can appear where a variable subset is expected. `<domain-set>` shall resolve either to a real subset or to a real value. When it is dimensionless, it is assumed to be specified in the dimension units of the variable. Otherwise the dimension give shall be compatible with one of the variable. `<defuzzify-method>` specifies the defuzzification method to be applied. It may appear only once:

- `coa` indicates the center of area method;
- `cog` indicates the center of gravity method;
- `cogs` indicates the discrete center of gravity method;
- `lm` indicates the leftmost maximum method;
- `rm` indicates the rightmost maximum method.

The default value is introduced by the keyword `default`. It is used when the defuzzification fails. The value can be specified either as an expression resolved to a real value. The value when dimensionless assumes the dimension of the variable. The keyword `nc` (no change) indicates that defuzzification fault should not change the value. The optional accumulation method specification is defined by `<method>`. The only legal value is `max`, because all others are incompatible with the possibility theory. The following example illustrates definition of the linguistic terms for the variable Power declared above:

> `defuzzify Power` |  |
> `term Low := (-100.0, 1)(10.0, 0);` | – | W is assumed
> `term Zero := 0 W;` | – | Singleton value
> `term Safe_Range := 1..2 [hp];` | – | Converted to W as necessary
> `term High := (800, 0)(2000, 0)[W];` |  |
> `method : COG;` | – | Using Center of Gravity
> `default := 0 W;` | – | What to do when defuzzification fails
> `end_defuzzify` |  |

### 3.3. Types of predicates

`<predicate>` is an expression involving a predicate variable and a constant using a set-theoretic or comparison operations. The following is an example of a predicate:

> `Power is in Safe_Range`

Predicates form a lattice. They can be further combined using the operations `and`, `⋀`, `not`, `¬`, `or`, `⋁`, `xor` and also appear in order brackets `(``)`. Other methods are infeasible in the possibility theory:

> `<predicate-expression> ::=`
> | `{` | `<predicate>`
> | `|` | `<predicate-expression>{ and | or | xor | ⋀ | ⋁ }<predicate-expression>`
> | `|` | `{ not | ¬ }<predicate-expression>`
> | `|` | `(<predicate-expression>)`
> | `}` |

The following example represents a `<predicate-expression>`:

> `Power is in Safe_Range and Power < 200 W`

## 4. Operations

The language defines prefix, dyadic, postfix and bracket operations. The operations are executed from left to the right and associated according to their precedence. Operations with higher precedence take their operands first.

### 4.1. Prefix operations

Prefix operations appear before the operand. They are:

Operation | Precedence | Code point | Description
`+`x | 6 |  | Unary plus
`-`x | 6 |  | Unary minus
`abs` x | 6 |  | Absolute value
`not` x | 6 |  | Logical not and set-complement
`¬`x | 6 | 00AC16 | Logical not
`not in` x | 6 |  | Set-complement, allowed only after the dyadic operation `is`

Unary `+` and `-` cannot appear after the following operations without brackets: `+`, `-`, `abs`, `*`, `/`, `**`. For example the following expressions are illegal:

> `2++2` | – | Illegal, must be |  | `2+(+2)`
> `5.0**-2` | – | Illegal, must be |  | `5.0**(-2)`
> `- -3.0` | – | Illegal, must be |  | `-(-3.0)`

Unary `abs` cannot appear before `**`. For example the following expression is illegal:

> `abs(-2)**2` | – | Should be disambiguated as |  | `(abs (-2))**2`
> |  | or as |  | `abs ((-2)**2)`

Unary `not in` may appear only after `is` in the expressions like:

> `Pressure is not in 1..200 [Pa]`

Which is an equivalent to:

> `not (Pressure in 1..200 [Pa])`

### 4.2. Dyadic operations

Dyadic operations have two operands and appear between them. The following table lists the dyadic operations and their precedence:

Operation | Precedence | Code point | Description
x `and` y | 0 |  | Logical and or set intersection
x `⋀` y | 0 | 22C016 | Logical and
x `or` y | 0 |  | Logical or or set union, the operands must be elements or sets
x `⋁` y | 0 | 22C116 | Logical or
x `xor` y | 0 |  | Logical xor or set difference, equivalent to `(`x `and not(`y`)) or (not(`x`)` `and` y`)`
x `in` y | 1 |  | Subset test operands can be elements, sets, one of them can be a variable
x `is` y | 1 |  | Equivalent to x `in` y
x `is in` y | 1 |  | Equivalent to x `in` y
x `not in` y | 1 |  | Equivalent to both `not(`x `in` y`)`
x `⊆` y | 1 | 228616 | Subset test, equivalent to x `in` y, with x is required to be a set or a variable
x `⊇` y | 1 | 228716 | Equivalent to y`⊆`x
x `⊈` y | 1 | 228816 | Equivalent to `not(`x`⊆`y`)`
x `⊉` y | 1 | 228916 | Equivalent to `not(`y`⊆`x`)`
x `∈` y | 1 | 220816 | Member test, equivalent to x `in` y, with x is required to be an element or a variable
x `∋` y | 1 | 220B16 | Equivalent to y`∈`x
x `∉` y | 1 | 220916 | Equivalent to `not(`x`∈`y`)`
x `∌` y | 1 | 220C16 | Equivalent to `not(`y`∈`x`)`
x `=` y | 1 |  | Equality
x `/=` y | 1 |  | Equivalent to `not(`x`=`y`)`
x `≠` y | 1 | 226016 | Equivalent to `not(`x`=`y`)`
x `<` y | 1 |  | Less
x `<=` y | 1 |  | Less or equal
x `≤` y | 1 | 226416 | Less or equal
x `>` y | 1 |  | Greater
x `>=` y | 1 |  | Greater or equal
x `≥` y | 1 | 226516 | Greater or equal
x `⋂` y | 2 | 22C216 | Set intersection, the operands can be sets or elements
x `⋃` y | 2 | 22C316 | Set union, the operands can be sets or elements
x `..` y | 3 |  | Range
x `^` y | 3 |  | Membership association (α-cut)
x `+` y | 4 |  | Addition
x `-` y | 4 |  | Subtraction
x `&` y | 4 |  | Concatenation
x `*` y | 7 |  | Multiplication
x `/` y | 7 |  | Division
x `**` y | 8 |  | Exponentiation
x `.` y | 11 |  | Component

The lattice operations like `and` and `or` cannot be associated without brackets. For example, the following expression is illegal and must be disambiguated:

> `Power is Low and Power is High or Power is Zero`

The following table illustrates legal and illegal associations of the lattice operations:

| `and` | `⋀` | `or` | `⋁` | `xor` | `⋂` | `⋃`
`and` | + | + | - | - | - | + | +
`⋀` | + | + | - | - | - | + | +
`or` | - | - | + | + | - | + | +
`⋁` | - | - | + | + | - | + | +
`xor` | - | - | - | - | + | + | +
`⋂` | + | + | + | + | + | + | +
`⋃` | + | + | + | + | + | + | +

The rule is that two operations of different semantics may not be associated when their results and operands are of the same type. The rationale is that the results of different associations shall be either same or else the expression can be disambiguated using the types of operands.

The operation `**` cannot be associated without brackets. For example the following expression is illegal:

> `2**2**3` | – | Should be disambiguated as |  | `(2**2)**3`
> |  | or as |  | `2**(2**3)`

### 4.3. Postfix operations

Postfix operations appear after the operand:

Operation | Precedence | Description
x`<power>` | 8 | Power operation

Power is a superscript integer with the syntax:

> `<power>` | `::=` | `<superscript-decimal-integer>`
> `<superscript-decimal-integer>` | `::=` | `[<superscript-sign>]<superscript-decimal-numeral>`
> `<superscript-decimal-numeral>` | `::=` | `<superscript-decimal-digit>[<superscript-decimal-numeral>]`
> `<superscript-decimal-digit>` | `::=` | `0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9`
> `<superscript-sign>` | `::=` | `+ | -`

The power operation cannot be associated without brackets. For example the following expression is illegal:

> `22 3` | – | Should be disambiguated as |  | `(22)3`
> |  | or as |  | `2**23`

### 4.4. Brackets

Operation | Precedence | Example | Description
`(`x`)` | - | `(5+1)*2` | Ordering brackets
`(`x`,`y`)` | - | `(5,1)` | Singleton composition
x`(`y`,`z`)` | 8 | `(1,0)(1,1)(10,1)(10,0)` | Membership function composition
x `[`y`]` | 3 | `(2.0,0)(4.0,1)(5.0,0)[°C]` | Scaling
`[`x`,`y`]` | - | `[1,20]` | Interval, range composition

### 4.5. Numeric operations

Numeric operations are applied to the operands of constant numeric types.

#### 4.5.1. Arithmetical numeric operations

The numeric arithmetical operations are prefix `+`, `-`, `abs`, dyadic `+`, `-`,`*`, `/`, `**`, postfix `<power>`.

An unary arithmetical operation (`+`, `-`, `abs`, `<power>`) yields the result of the same type as the operand. A dimensioned operand can be exponentiated only if it is not shifted (`20°C` is shifted.) Examples of unary operations:

> `5 m2` | – | 5 square meters
> `abs (-4)` | – | 4
> `23` | – | 8

A dyadic arithmetical operation yields an integer (Integer) result if both operands are integers. Otherwise the result is of real (Real) type. Dimensioned operands must have compatible types. Shifted dimensioned constants can be multiplied and divided only by dimensionless constants. The second operand of `**` shall be dimensionless. Further if the first operand has a dimension, it cannot be shifted and the second operand must be a non-negative integer (Integer).

#### 4.5.2. Relational numeric operations

Relational operations `=`, `/=`, `≠`, `>`, `<`, `<=`, `≤`, `>=`, `≥` are defined for all numeric types and yield a value of Truth_Value. When one operand is of real (Real) type, another is automatically converted to the same type. The dimensions of the operands after necessary conversions must be compatible. Examples of numeric relational operations:

> `5 m2 = 5 yd2` | – | 0 of Truth_Value: 5 square meters is not equal to 5 square yards
> `10 > 1` | – | 1 of Truth_Value

#### 4.5.3. Numeric membership tests

The membership tests operations are `in`, `is`, `is in`, ∈, ∉, `not in` with the left operand of a numeric type and the operations ∋, ∌ with the right operand of a numeric type. The operations `in`, `is`, `is in`, ∈ are equivalent. The operations `not in`, ∉ are equivalent and x∉y is identical to y∈x. The operation x∋y is identical to y∈x. The operation x∌y is identical to y∉x. The non-numeric operand is a set type. Operands are converted as follows:

- The numeric operand is converted to Real if the set operand has either of the types Real_Singleton, Real_Range, Real_Set or Domain_Subset or Intuitionistic_Domain_Subset with a real domain set.
- The set operand is converted from Integer_Singleton, Integer_Range, Integer_Set to Real_Set if the numeric operand is of Real.

After types conversion the numeric operand should have the same type and compatible dimension as the domain set of the set operand. The result of a membership operation is of Intuitionistic_Truth_Value. The examples of membership tests:

> `5 in [1,6]` | – | [1:1]
> `1..5∋2` | – | same as above
> `6.0 not in (6.0,1)` | – | [0:0]
> `6.0 m in (6,0)(6,1)(6,0)[m]` | – | [1:0]

#### 4.5.4. Singleton composition

Round brackets `()` with two items compose a singleton. The first item is of numeric type, it identifies the domain set value. The second item is of Truth_Value. The singleton type is determined by the numeric type. Integer produces Integer_Singleton. Real does Real_Singleton. Examples of singletons:

> `(5,1)` | – | Integer_Singleton, the value 5 with the truth value 1
> `(0.5 m, 0.5)` | – | Real_Singleton, the value 0.5 meter with the truth value 0.5

#### 4.5.5. Numeric interval composition

Square brackets `[]` with two items and the operation ellipsis `..` compose a range (or equivalently an interval). The first item / operand is the lower bound of the range. The second item / operand is the upper bound. When one item / operand is of real (Real) type, another is converted to the same type as necessary. After necessary conversions, the lower bound must be less or equal than the upper bound. The dimensions of bounds must be compatible. The result type is determined by the types of the bounds after applying necessary conversions. Integer bounds produce a result of Integer_Range. Real bounds do a result of Real_Range. Examples of ranges:

> `[1, 20]` | – | Integer_Range range from 1 to 20
> `1..20` | – | Same as above
> `[1 m, 20 m]` | – | Real_Range 1..20 meter
> `1 m..20 m` | – | Same as above

#### 4.5.6. Scaled numeric values

A numeric value in square brackets `[]` specified after a numeric multiplies the operand before the brackets. Shifted dimensioned operand can be multiplied and divided only by a dimensionless one. The result has Real. Examples of scaling numeric constants:

> `1 [2]` | – | 2 (of Real)
> `2.0 [°C]` | – | 2 Celsius degree
> `1 m [1/s]` | – | 1 m/s

### 4.6. Logical operations

Logical operations are `and`, `⋀`, `not`, `¬`, `or`, `⋁`, `xor` applied to the operands of logical types Truth_Value and Intuitionistic_Truth_Value. The result of logical `not`, `¬` has the same type as the operand. For the dyadic operations `and`, `⋀`, `or`, `⋁`, `xor` if one operand has the type Intuitionistic_Truth_Value, then another is converted to the same type. The result a dyadic logical operation is same as the type of the operands after necessary conversions applied. Examples of logical operations:

> `1 and 0.6` | – | 0.6 of Truth_Value
> `1 and [1:0.6]` | – | Intuitionistic_Truth_Value with the possibility 1 and the necessity 0.6
> `[0.3:0.6] or [0.7:0.0]` | – | Intuitionistic_Truth_Value with the possibility 0.7 and the necessity 0.6
> `not [1:0.6]` | – | Intuitionistic_Truth_Value with the possibility 0.4 and the necessity 0

### 4.7. Set operations

Set operations are applied to the operands representing sets:

- Integer_Singleton,
- Integer_Range,
- Integer_Set,
- Real_Singleton,
- Real_Range,
- Real_Set,
- Domain_Subset,
- Intuitionistic_Domain_Subset.

#### 4.7.1. Lattice set-operations

Lattice operations `and`, `⋂`, `not`, `¬`, `or`, `⋃`, `xor` when applied to sets produce a set.

The result of `not` has the type determined by the operand's type:

- For Integer_Singleton and Integer_Range the result of `not` has the type Integer_Set;
- For Real_Singleton and Real_Range the result of `not` has the type Real_Set;
- For other types the result of `not` has the type of the operand.

For the dyadic operations `and`, `⋂`, `or`, `⋃`, `xor` the following types conversions are automatically applied:

- Integer_Singleton or Integer_Range operand is converted to Integer_Set if another operand has either the same or Integer_Set type;
- Real_Singleton or Real_Range operand is converted to Real_Set if another operand has either the same or Real_Set type;
- Integer_Singleton, Integer_Range, Integer_Set, Real_Singleton, Real_Range or Real_Set operand is converted to Domain_Subset if that is the type of another operand;
- Any operand is converted Intuitionistic_Domain_Subset if that is the type of another operand.

Dimensions of the operands of `and`, `⋂`, `or`, `⋃`, `xor` shall be compatible. The result of an operation is the type of the operands after necessary conversions. Examples of lattice operations:

> `1..5 and 2..4` | – | Integer set containing 2, 3, 4 (the type is Integer_Set)
> `not (2, 1)` | – | Integer set containing all integer values except 2 (the type is Integer_Set)
> `1..5 and (1.0, 0.5)` | – | Real set containing 1 with the truth level 0.5 (the type is Real_Set)
> `high or low` | – | Fuzzy domain subset containing the linguistic variables high and low (the type Domain_Subset)
> `high or low^[1.0:0]` | – | Intuitionistic domain subset containing the linguistic variables high and low with the possibility 1 and the linguistic variable high with the necessity 1 (the type Intuitionistic_Domain_Subset)

#### 4.7.2. Relational operations on sets

Relational operations `=`, `/=`, `≠` are defined for all set types and yield a value of Intuitionistic_Truth_Value. Sets equality x `=` y is defined as x `in` y `and` y `in` x. Inequality x `/=` y is defined as `not(`x`=`y`)`. Thus both are commutative. The operands are automatically converted as described for the operations `and`, `or`, `xor`. Dimensions of the operands must be compatible. Examples of relational operations:

> `1..5 = [0.5, 1]` | – | [1:0] (uncertain)
> `1..5 /= 10..11` | – | [1:1] (true)

#### 4.7.3. Membership operations

The membership tests operations are `in`, `is`, `is in`, ∈, ∉, `not in` with the left operand of a numeric type and the operations ∋, ∌ with the right operand of a numeric type. For detailed description see numeric membership tests.

#### 4.7.4. Subset test operations

Subset relation operations are `in`, `is`, `is in`, `⊆`, `⊇`, `⊈`, `⊉`, `not in`. The operations `in`, `is`, `is in`, `⊆` are equivalent. The operations `⊈`, `not in` are equivalent and x`⊈`y is identical to `not(`x`⊆`y`)`. The operation x`⊇`y is identical to y`⊆`x. The operation x`⊉`y is identical to y`⊈`x. Example of subset operations:

> `2..3 ⊆ 1..5` | – | [1:1] (true)

#### 4.7.5. Membership function composition

The ternary operation x`(`y`,`z`)` composes a fuzzy set by specifying its membership function per point. The operands in brackets shall compose a singleton. The singleton specifies the rightmost point of the membership function. The first operand shall denote a set of either of the following types:

- Integer_Singleton,
- Integer_Range,
- Integer_Set,
- Real_Singleton,
- Real_Range,
- Real_Set.

The following type conversions are applied to the operands:

- The left operand is converted to Real_Set when the singleton operand has the type Real_Singleton;
- The singleton is operand is converted to the type Real_Singleton when the left operand has the type Real_Singleton, Real_Range or Real_Set;
- In all other cases the left operand is converted to Integer_Set.

The result of the operation has the type of the left operand after necessary conversions. The dimensions of the left operand and the singleton shall be compatible. Further, the singleton operand shall specify the membership function for a point greater or equal to the rightmost point in the left operand. The membership function of the result is extrapolated to the right using the truth value specified. When the left operand is a singleton, then the truth value it specifies is extrapolated to the left. It is allowed to specify several values of the membership function in one point. In which case the result is intuitionistic in these points. Examples of membership composition:

> `(1 m,0)(5 m,1)(10 m,0)` | – | Triangular real set (the type is Real_Set)
> `(1,0)(1,1)(10,1)(10,0)` | – | Rectangular membership function (the type Integer_Set)
> `(1.1,0.6)(1.1,0.2)(1.1,1)(1.1,0.3)` | – | Pulse membership function constant 0.6 left of 1.1 and 0.3 right of 1.1. In 1.1 it goes down to 0.2 and up to 1 (the type is Real_Set)

#### 4.7.6. α-cut operation

The dyadic operation `^` yields α-cut of a set. The left operand is of one of the set types. The right operand is a truth value of either Truth_Value or Intuitionistic_Truth_Value. The left operand is automatically converted:

- To Domain_Subset when the right operand has the type Truth_Value and the type of the left operand is not Intuitionistic_Domain_Subset.
- To Intuitionistic_Domain_Subset in all other cases.

The result of the operation has the type of the left operand after necessary conversions. Examples of α-cuts:

> `Power is (low^0.5 or High)` | – | Here the linguistic variable low is cut at the level of 0.5. The result is of Domain_Subset, to which the linguistic variable high is added.
> `Power is 1..20[W]^[1:0.5]` | – | The value has rectangular membership functions for possibility and necessity. The possibility rectangle has the level 1. The necessity one does 0.5

#### 4.7.7. Scaled set values

A numeric value in square brackets `[]` specified after an operand of set type multiplies the elements of the set. The set operand may have one of the following types:

- Integer_Singleton,
- Integer_Range,
- Integer_Set,
- Real_Singleton,
- Real_Range,
- Real_Set.

The following type conversions are applied to the set operand:

- Integer_Singleton is converted to Real_Singleton;
- Integer_Range is converted to Real_Range;
- Integer_Set is converted to Real_Set.

The result of the operation has the type of the left operand after necessary conversions. Shifted dimensioned operand can be multiplied and divided only by a dimensionless one. The result of scaling has the type of the set operand. Examples of scaling set constants:

> `1..2 [m]` | – | 1 m .. 2 m (of Real_Range)
> `(2.0,0)(4.0,1)(5.0,0)[°C]` | – | A triangular set of Celsius degree (of Real_Range)

### 4.8. String operations

String operations are defined on the types Character and String.

#### 4.8.1. Concatenation

The operation `&` takes two operands of either Character or String and yields a String result. Example of using concatenation:

> `'a' & "bcde"` | – | String abcde

#### 4.8.2. Relational string operations

Relational operations `=`, `/=`, `≠`, `>`, `<`, `<=`, `≤`, `>=`, `≥` are defined on operands of Character and String types. They yield a value of Truth_Value type. When one operand is of real (Real) type, another is automatically converted to the same type. The dimensions of the operands after necessary conversions must be compatible. Examples of numeric relational operations:

> `'b' > ""` | – | 1 of Truth_Value
> `"abc" > "abcdef"` | – | 1 of Truth_Value

### 4.9. Predicate operations

Predicate operations are applied to predicates and predicate variables.

#### 4.9.1. Relational operations

The relational operations on predicate variables are `=`, `/=`, `≠`, `>`, `<`, `<=`, `≤`, `>=`, `≥`, `in`, `is`, `is in`, `⊆`, `⊇`, `⊈`, `⊉`, `∈`, `∉`, `∋`, `∌`, `not in`. One of the operands shall be a predicate variable. Other operand depends on the operation:

- for the equality and inequality `=`, `/=`, `≠` the non-variable operand shall be either of a numeric or of a set type;
- for the comparisons `>`, `<`, `<=`, `≤`, `>=`, `≥` the non-variable operand shall be of a numeric type;
- for subset tests `in`, `is`, `is in`, `⊆`, `⊇`, `⊈`, `⊉`, `∈`, `∉`, `∋`, `∌`, `not in` the non-variable operand shall be of a set type.

The non-variable operand is automatically converted as follows:

- Integer is converted to Real if the variable is continuous;
- Integer_Singleton is converted to Real_Singleton if the variable is continuous;
- Integer_Range is converted to Real_Range if the variable is continuous;
- Integer_Set is converted to Real_Set if the variable is continuous.

After necessary conversions the domain set of the non-variable operand and its dimension shall match one of the variable. The result of a relational operation is a predicate. The equality `=` and the inequality `/=`, `≠` are commutative.

- When the non-variable operand is of a numeric type then both var `=` x and x `=` var are equivalent to var `in` x.
- When the non-variable operand is of a set type, then both var `=` x and x `=` var are equivalent to var `in` x `and` x `in` var.

The inequality `/=`, `≠` is defined through equality as `not(`x`=`y`)`.

Examples of predicates:

> `Power is low` | – | The variable Power is contained in the linguistic variable low
> `Zero in Power` | – | Power contains the linguistic variable Zero
> `Power >= 10 W` | – | Power is contained in ]10 W ,∞ W[
> `10 W <= Power` | – | Same as above
> `Power = 0 W` | – | Power is 0 W (It is contained in [0 W,0 W])
> `Power = Zero` | – | Power contains and is contained in Zero

#### 4.9.2. Lattice operations

Lattice operations `and`, `⋂`, `or`, `⋃`, `xor`, `not`, `¬` when applied to predicate produce a predicate. Examples of lattice operations on predicates:

> `not (Power is low)` | – | Equivalent to Power is not contained in low
> `Power is high and Pressure >= 1 kPa` |  |

The operation `not`, `¬` when applied to a predicate variable produces its complement. Examples of predicate variable complements:

> `(not Power) is low` | – | Power is contained in low
> `Zero is not Power` | – | Zero is not contained in Power, i.e. it is contained in Power

Because the law of excluded middle does not hold, a realization of variable does not necessarily defines one of its complement.

#### 4.9.3. Name qualification operation

The component operation `.` is applied to the identifiers to specify a qualified name. The left identifier is a predicate variable. The right identifier is the domain value. Example of a qualified name:

> `Power.Low` | – | Low of Power

## 5. Program structure

An IFCL program consists of a function block which has the following syntax:

> `<IFCL-program>` | `::=` | `function_block <identifier> <program-body> end_function_block`
> `<program-body>` | `::=` | `<program-block> [<program-body>]`
> `<program-block>` | `::=` | `{` | `<input-variables-block>`
> |  | `|` | `<output-variables-block>`
> |  | `|` | `<fuzzify-block>`
> |  | `|` | `<defuzzify-block>`
> |  | `|` | `<rules-block>`
> |  | `}` |

The program has the name specified by an `<identifier>` following the keyword `function_block`. It ends with the keyword `end_function_block`. The program consists of a number of `<program-block>` items. The following is an example of a valid program:

`function_block Test var_input Distance : real [m]; Angle : real [°]; I : integer 1..20; (* Integer variable range 1..20 *) Color : nominal (red, blue, white); T : real [°C]; V : float [°C] 10 range 1..2*10; end_var var_output Power : Real [W]; Valve : Real; end_var fuzzify T term Chill := (-10,1)(-4,0); -- °C is assumed term Cold := ( 11,1)(17,0) [°C]; term Tepid := ( 3,0)( 8,1)(21,1)(28,0) [°C]; term Warm := ( 15,0)(21,1)(29,1)(35,0) [°C]; term Hot := ( 25,0)(28,1) [°C]; end_fuzzify defuzzify Valve term Open := 1; term Closed := 0; default := 0; method : CoA; end_defuzzify fuzzify Distance term too_far := (-5,1)( 0,0); term zero := (-5,0)( 0,1)( 5,0); term close := ( 0,0)( 5,1)(10,0); term medium := ( 5,0)(10,1)(22,0); term far := (10,0)(22,1); end_fuzzify fuzzify Angle term neg_big := (-50,1)(-5,0); term neg_small := (-50,0)(-5,1)( 0,0); term zero := ( -5,0)( 0,1)( 5,0); term pos_small := ( 0,0)( 5,1)(50,0); term pos_big := ( 5,0)(50,1); end_fuzzify defuzzify Power term neg_high := -27; term neg_medium := -12; term zero := 0; term pos_medium := 12; term pos_high := 27; accu : MAX; method : CoGS; default := 0; end_defuzzify ruleblock Rules and : MIN; if T is cold then Valve is closed; end_ruleblock ruleblock No1 and : MIN; rule 1: if distance is far and angle is zero then power is pos_medium; rule 2: if distance is far and angle is neg_small then power is pos_high; rule 3: if distance is far and angle is neg_big then power is pos_medium; rule 4: if distance is medium and angle is neg_small then power is neg_medium; rule 5: if distance is close and angle is pos_small then power is pos_medium; rule 6: if distance is zero and angle is zero then power is zero; end_ruleblock end_function_block`

### 5.1. Rules definition

> `<rules-block>` | `::=` | `rule_block <identifier> <rules-block-body> end_rule_block`
> `<rules-block-body>` | `::=` | `<rule>; [<rules-block-body>]`
> `<rule>` | `::=` | `{` | `<accumulation-method>`
> |  | `|` | `<activation-method>`
> |  | `|` | `<intersection-method>`
> |  | `|` | `<production-rule>`
> |  | `|` | `<union-method>`
> |  | `}` |
> `<accumulation-method>` | `::=` | `accu : <method>`
> `<activation-method>` | `::=` | `act : <method>`
> `<intersection-method>` | `::=` | `and : <method>`
> `<union-method>` | `::=` | `or : <method>`
> `<method>` | `::=` | `{ asum | bdif | bsum | max | min | prod }`

The only allowed methods for `<accumulation-method>` and `<union-method>` is `max`. The only allowed method for `activation-method` and `intersection-method` is `min`. Other methods are infeasible in the possibility theory.

> `<production-rule>` | `::=` | `[rule <rule-number>:] if <antecedent> then <consequent>`
> `<rule-number>` | `::=` | `<integer>`
> `<antecedent>` | `::=` | `<predicate-expression>`
> `<consequent>` | `::=` | `<predicate-expression>`

When `<rule-number>` is specified in a rule block all production rules of the block shall be numbered. The numbers may not repeat and shall compose a contiguous range beginning at 1. When the rules block has numbered rules, when stored in a training set these numbers are the numbers of the training examples in the set.

## 6. Table of Contents

1. Introduction 2. Lexical elements 2.1. Character set 2.2. Comments 2.3. Literals 2.3.1. Integer literals 2.3.2. Real literals 2.3.3. Dimensioned literals 2.3.4. Truth values 2.3.5. String and character literals 2.4. Identifiers 3. Types 3.1. Types of constants 3.2. Types of predicate variables 3.2.1. Declaration of predicate variables 3.2.2. Nominal predicate variables 3.2.3. Integer variables 3.2.4. Float variables 3.2.5. Linguistic set variables 3.3. Types of predicates 4. Operations 4.1. Prefix operations 4.2. Dyadic operations 4.3. Postfix operations 4.4. Brackets 4.5. Numeric operations 4.5.1. Arithmetical numeric operations 4.5.2. Relational numeric operations 4.5.3. Numeric membership tests 4.5.4. Singleton composition 4.5.5. Numeric interval composition 4.5.6. Scaled numeric values | 4.6. Logical operations 4.7. Set operations 4.7.1. Lattice set-operations 4.7.2. Relational operations on sets 4.7.3. Membership operations 4.7.4. Subset test operations 4.7.5. Membership function composition 4.7.6. α-cut operation 4.7.7. Scaled set values 4.8. String operations 4.8.1. Concatenation 4.8.2. Relational string operations 4.9. Predicate operations 4.9.1. Relational operations 4.9.2. Lattice operations 4.9.3. Name qualification operation 5. Program structure 5.1. Rules definition 6. Table of contents