Event Trees Transformation for

Rule Bases Engineering

A.F. Berman*, N.O. Dorodnykh*, O.A. Nikolaychuk* and A.Yu. Yurin*,** * Matrosov Institute for System Dynamics and Control Theory, Siberian Branch of the Russian Academy of Sciences

(ISDCT SB RAS), Irkutsk, Russia ** Irkutsk National Research Technical University (IrNRTU), Irkutsk, Russia

iskander@icc.ru

Abstract - The paper describes an approach for rule

bases engineering by transforming event tree diagrams

which are applied in the field of failure and risk analysis of

technical systems. The approach is based on the

identification and extraction of structural cause-effect

elements of event trees and their transformation into the

elements of a target knowledge representation language, in

particular, CLIPS. Description of an extended event tree

formalism, an event tree metamodel and transformation

technique are presented. An illustrative example describes

the development of a rule-based knowledge base for

diagnosing and forecasting the states of complex technical

systems based on the approach proposed.

Keywords – knowledge acquisition; knowledge base; rules;

event trees; model transformation, code generation; CLIPS

I. INTRODUCTION

Rule-based knowledge representation languages are still the most widespread and popular for industrial diagnostic expert systems engineering [1] despite the increasing popularity of semantic technologies, in particular, ontologies. One way to increase the efficiency of knowledge bases engineering with the aid of them is the use of principles of visual programming and automatic code generation. That in turn results to minimize the risks of programming errors, to use the previously developed information in the form of visual models, and to increase the participation degree and responsibility of non-programming users in the development process.

There are many universal languages (standards) for domain knowledge visualization (e.g., DFD, IDEF0, IDEF5, UML, etc.) and specialized notations focused on certain knowledge representation formalisms (e.g., Rule Visual Modeling Language (RVML) [2], UML-Based Rule Modeling Language (URML) [3]), but domain experts prefer to use domain-specific notations that have a system-wide focus and oriented on knowledge systematization or decision-making support (e.g., concept maps, mind maps, fishbone diagram, Venn diagram, feature models, semantic models, fuzzy conceptual models, etc.). These models include tree-like semantic structures, such as fault trees and event trees used in the field of failure and risk analysis of technical systems [4-6]. These notations provide effective description, clear and convenient representation of domain experts’ knowledge.

In this paper we propose to use conceptual models in the form of event trees as a data source for rule-based knowledge bases engineering.

There is special software to modeling event trees: RELEX Windchill FTA (Relax Software Corporation) [7], Risk Spectrum (Relcon AB) [8], SAPHIRE [9], RAM Commander ETA (A.L.D. Group) [10], Reliability Workbench incorporating FaultTree+ (ISOGRAPH) [11] and others. These systems support visualization and building event trees but don’t provide a way to synthesize (generate) any source codes including for knowledge representation languages. Moreover, analyzed software implies the use of knowledge contained in the created trees for solving mathematical problems (such as search of minimal cut set, events with maximum or minimum probability, and etc.) but not for engineering intelligent decision support systems or knowledge bases.

Also it should be noted that today there are no unified standards (or specifications) for representation and serialization of event trees, and each software uses its own format. However, most of them are XML-based, because XML is the most common method for integration of software that provides the exchange of information between applications.

Thus, this paper is devoted to an approach for automated development of rule-based knowledge bases by transforming event trees serialized in a XML-based format. The C Language Integrated Production System (CLIPS) [12] is selected as the target knowledge representation language for compatibility with our early developments [2, 13].

II. THE PROBLEM STATEMENT

The problem of knowledge base engineering on the basis of event trees analysis can be represented as a models transformation problem [14]. In this case, the transformation is the process of an automatic generation of a target knowledge base from a source model according to a set of transformation rules. Transformation rules describe how one or more constructs of the source language can be transformed into one or more constructs in a target knowledge representation language.

Let’s formalize the problem statement as follows:

KBCMT ET : , (1)

1328 MIPRO 2019/CIS

where ETCM is a source conceptual model in the form of

an event tree; KB is a target knowledge base in the form

of CLIPS code, CLIPSCodeKB .

Thus, it is necessary to define a set of transformation rules (T) in the context of engineering rule-based knowledge bases and implement them in the form of a special tool (a transformation module).

The previously developed technology [15] that was implemented in the form of a web-based program system – Knowledge Base Development System (KBDS) [13] was used. This technology supports the creation of software components (transformation modules) designed for converting the source conceptual models, represented in XML-like formats, into the knowledge base codes of the target knowledge representation language, in particular, CLIPS.

III. EVENT TREES

A. A standard formalism

Event tree formalism [16] is a graphical technique that uses boolean operators to evaluate the consequences of a risk by drawing (mapping) all probable outcomes from an initiating event in their logical sequence.

Event trees are used to determine and analyze the variants of emergency including complex interactions between technical systems. Event tree building procedure is based on a direct logic. In general, this method can be used to analyze failures, accidents and emergency, where the initial state is considered as the main event, i.e. a state of a technical object at the operation start time.

B. Domain-specific extention

Analysis of some domain problems, in particular, the problem of industrial safety expertise [17], showed the need for domain-specific extension of the standard event tree formalism in order to obtain more complete information about the investigated events, their causes and consequences.

In particular, based on the [18-20], it is defined the followings:

- in most cases any investigated process is a sequence of states that unite groups of events on certain grounds. In the field of technical diagnostics, as a rule, there are two main states of the technical object and its structural elements: an operation state and failure state, which in turn can include a set of intermediate states, depending on the classification basis;

- each of the states has a certain initial event that is determined not only by the previous states (events), but also by additional factors, such as external effecting factors and properties of the object under investigation.

In this connection, it is proposed to extend the standard event tree formalism (and its visual representation), in particular:

- to define the levels of the event tree corresponding to the stages of the process under investigation. In particular,

when solving problems of predicting the states of technical systems, these levels may have the following names: defect, damage, destruction, emergency;

- to define a specialized event (represented in the form of a triangle) describing the initial event of a certain stage (or level, state, sub-state). This event corresponds to the concept of mechanism [17] and can be considered as a combination of the object properties and effecting factors that determine the development of the processes under investigation on a certain stage;

- to determine the possibility for describing a mechanism by a composition of different factors in the form of the followings logical rules:

IF (1property AND … AND

nproperty ) AND

(1factor effecting AND … AND

nfactor effecting )

THEN the mechanism of j-stage AND

(nevent...event1 ), when is a some logical

operation, ,, .

C. An event tree template and metamodel

A generalized event tree template (Figure 1) is obtained on the basis of extensions proposed. This template describes stages, sequence of events and the mechanisms of their occurrence and can be used as an event tree draft for experts. In the absence of tree elements that extend the standard formalism, we get a standard event tree.

A metamodel of an extended event tree (abstract syntax), which defines in abstract form the main concepts of the extended event tree formalism, is shown in Figure 2. This metamodel is built using the Ecore meta-modeling language [21] and further is used as a source metamodel when developing transformation rules describing the correspondences between the elements of this metamodel

Figure 1. A template of an extended event tree

MIPRO 2019/CIS 1329

and a target metamodel of rule-based knowledge base.

D. Event tree seralization format

Currently, there is no unified standard format (a standard textual notation) for the event tree representation, and designed for computer-aided processing. So, it is proposed a XML serialization format for extended event

trees formalism. Table 1 contains XML format description (a concrete syntax).

IV. EVENT TREES TRANSFORMATION TECHNIQUE

Event trees transformation technique is based on the generalized algorithm for transformation of conceptual models into knowledge base source codes that described in [13]. The main task of the proposed algorithm is to transform elements of an extended event tree (presented in XML format) into constructions of a knowledge representation language (CLIPS). So, the following main steps can be defined:

Step 1: Building the event tree describing the sequence of some emergency events, and their serialization in XML format. It should be noted that various tools for event trees modeling can be used at this step.

Step 2: Analyzing a XML structure of a serialized event tree. In this case, the main tree elements are extracted and matched with the elements of a rule-based model. This model is an universal means of intermediate representation of extracted knowledge in the form of logical rules which are independent form the knowledge representation language used (e.g., CLIPS, Jess, Drools, RuleML, SWRL, etc.).

Step 3: Visualizing and modifying the obtained rule-based model in RVML notation [2].

Step 4: Generating a knowledge base source code in CLIPS format based on the rule-based model.

Thus, let’s define the transformation operator from (1):

KBRMRMCM TTT , , (2)

TABLE I. XML-LIKE FORMAT FOR REPRESENTATION OF EXTENDED

EVENT TREES

Main XML nodes Description

System Information about the object under investigation (e.g., plant, line, branch,

mechanical system, etc.)

Component Information about a structural hierarchy of the object under investigation

Element Information about a structural element of a

mechanical system

EventTree General information about the event tree

ProcessStage General information about the stage

InitialEvent Information about the mian initial event

Mechanism General information about the mechanism

Property Information about a property of of the object

under investigation (a system element)

EffectingFactor Information about an effecting factor

ProcessMechanism General information about the mechanism (an initial event of a certain stage)

Event Information about a concrete event and its

parameters

Operator Boolean operator: AND, OR, XOR

Figure 2. A metamodel of the extended event tree formalism

1330 MIPRO 2019/CIS

PRETXMLRMCM MMT : ,

CLIPSPRKBRM CodeMT :

when RMCMT is a set of rules for transformation of a

source extended event tree to a target rule-based model;

KBRMT is a set of transformation rules of the rule-based

model into CLIPS code; ETXMLM is a representation of an

extended event tree model in XML format; PRM is a representation of acquired knowledge in the form of a

rule-based model; CLIPSCode is a target CLIPS code.

Transformation rules for RMCMT and KBRMT are

described in terms of the domain-specific declarative language – Transformation Model Representation Language (TMRL) [22]. TMRL constructs make it possible to describe the elements of the transformation scenario in a declarative form, in particular, the rules for the correspondence between elements of a source metamodel and a target metamodel.

Examples of the correspondence between the main elements of an extended event tree diagram, a rule-based model and CLIPS are presented in Table 2.

Complex rules containing several conditions are formed on the basis of the mechanism. Complex rules containing several actions are formed on the basis of the process mechanism description, which leads to some set of subsequent events. Also, each event can cause one or more subsequent events. Therefore, such a chain of events may also correspond to rules.

It should be noted that each event in the tree, as well as the process mechanism can be assigned a certainty factor. The certainty factor value reflects the subjective degree of expert confidence in the occurrence of a specified event or mechanism.

V. IMPLEMENTATION

Implementation of the proposed technique was carried out using a specialized technology for automatic development of software components (converters) of intelligent systems [15] and the corresponding software – KBDS [13]. These converters provide the knowledge base code generation by transforming conceptual models.

In particular, an experimental software component (converter) was developed to generate a rule-based model

by transforming extended event trees. The process of component development is described in [15]. Therefore, let’s briefly summarize the main stages of this process:

Creating a new project for a certain component in KBDS.

Constructing (or generating) a source metamodel for an extended event tree using reverse engineering (extraction an abstract concepts and their relationships based on the analysis of a source XML document) or conversion of XML schema of a source event tree. The built metamodel for an extended event tree is sown in Figure 2.

Creating a transformation model (scenario) that describes correspondences (transformation rules) between the elements of the source metamodel of an extended event tree and the target metamodel of the knowledge representation formalism (a rule-based model), and linking it to the software component being created. The special graphic editor included in KBDS (see Figure 3) is used for formation of transformation rules.

Generating the transformation model code on TMRL.

Correcting the TMRL code for the transformation model (in particular: adding complex rules reflecting, for example, the homonymy relationship between the elements of the source and target metamodels).

The final synthesis of a software component is carried out on the basis of the generated transformation model.

VI. ILLUSTRATIVE EXAMPLE

Let’s consider an illustrative example of the proposed approach and software application for rule base engineering by transforming the event tree diagrams. Created knowledge base describes a cause and effect complex of changes in technical conditions of petrochemical equipment elements (tanks and apparatus), and it is used for industrial safety expertise tasks, in particular, for definition of some degradation processes (corrosion, corrosion fatigue) and their events.

Figure 3. A transformation model in a special editor

TABLE II. THE ELEMENTS CORRESPONDENCES

Extended event tree Rule-based model CLIPS

EventTree Model -

InitialEvent / Event FactTemplate / Fact Deftemplate

InitialEvent (name) /

Event (name) Slot

(slot

“<name>”)

Mechanism RuleTemplate / Rule defrule

Property / EffectingFactor

FactTemplate / Condition

deftemplate /

defrule

(consequent)

Property (name) / EffectingFactor

(name)

Slot (slot

“<name>”)

ProcessMechanism FactTemplate / Action deftemplate / defrule

(antecedent)

MIPRO 2019/CIS 1331

The main steps of knowledge base engineering with accordance of the proposed technique are the followings:

Step 1: Domain experts build extended event tree diagrams for degradation processes with using the template (see Figure 1) at different stages. In particular, the fragment on Figure 4 describes the “damage” stage for the “corrosion fatigue” degradation process. The technical object is a flange connection with angular diameter 6 in a strapping pipeline of a compressor. Built diagrams serialized as XML documents, a file fragment represented below:

<EventTree id="ET-1" name="Event tree" element="ELM-

1">

<InitialEvent id="IE-1" name="Failure of flange

connection AD 6"/>

<ProcessStage id="PS-1" name="Damage">

<ProcessMechanism id="MEC-1" name="Corrosion

fatigue" pnode="IE-1">

<Property id="P-MEC-1-1" name="material type"

value="steel"/>

<Property id="P-MEC-1-2" name="material alloying"

value="low alloy steel"/>

<Operator id="OPR-1" name="OR">

<Property id="P-MEC-1-3" name="technological

heredity" value="manufacturing defects"/>

<Property id="P-MEC-1-4" name="technological

heredity" value="surface damage due to exposure of

aggressive media"/>

</Operator>

<EffectingFactor id="EF-MEC-1-1" name="medium

type" value="active"/>

<EffectingFactor id="EF-MEC-1-2" name="medium

properties alternation" value="true"/>

<EffectingFactor id="EF-MEC-1-3"

name="mechanical load type" value="variable"/>

<EffectingFactor id="EF-MEC-1-4"

name="mechanical load cycle frequency" value="high"/>

<EffectingFactor id="EF-MEC-1-5"

name="mechanical load cycle value" value=">60

cycle/min"/>

</ProcessMechanism>

<Event id="EV-1" name="Corrosion-erosion damage of

the surface" certainty-factor="0,1" pnode="MEC-1"/>

<Event id="EV-2" name="Formation of damages

elongated in the direction of medium motion" certainty-

factor="0,1" pnode="EV-1"/>

<Event id="EV-3" name="Local destruction of

inclusions on the surface" certainty-factor="0,2"

pnode="MEC-1"/>

<Event id="EV-4" name="Microcrack formation on the

surface" certainty-factor="0,2" pnode="EV-3"/>

…

</ProcessStage>

…

</EventTree>

Step 2: The constructed diagrams are transformed into the rule-based model with the aid of a specialized converter. This converter uses information about XML tags (constructions) and their correspondences (see Tables 1 and 2).

Step 3: Obtained rule-based model can be visualized and modified with the use of RVML notation [2] (in particular, users specify certainty factors).

Step 4: CLIPS code generation based on Table 2 correspondence patterns.

The following CLIPS code corresponds to the formed rule-based model:

(deftemplate InitialEvent

(slot id)

(slot name))

…

(deftemplate EffectingFactor

(slot id)

(slot name)

(slot value))

…

(defrule ProcessMechanism-MEC-1

Figure 4. A fragment of an event tree diagram for corrosion fatigue

1332 MIPRO 2019/CIS

(declare (salience 4))

(Property (name "material type") (value "steel"))

(Property (name "material alloying")(value "low

alloy steel"))

(EffectingFactor (name "medium type")(value

"active"))

(EffectingFactor (name "medium properties

alternation")(value "true"))

(EffectingFactor (name "mechanical load type")(value

"variable"))

(EffectingFactor (name "mechanical load cycle

frequency")(value "high"))

…

=>

(assert

(ProcessMechanism (name "Corrosion fatigue"))

(ProcessStage (name "Damage"))

))

VII. CONLUSION

The paper describes the approach for rule bases engineering by analyzing and transforming extended event tree diagrams, which are applied in the field of failure and risk analysis of technical systems. The extension includes definition of levels describing different stages of the process under investigation, and specialized events corresponding to the mechanism concept.

The target knowledge representation language is CLIPS.

The proposed approach reduces the risk of programming errors at the stages of knowledge formalization and codification due to automatic source knowledge base codes generation, and also provides the ability for the domain experts to use domain-specific notations and domain models when engineering intelligent systems.

KBDS [13] and a previously developed technique [15] are utilized as a software and algorithmic platform for the proposed approach implementation. One of the results of this implementation is a software component (converter) with open REST API that can be used for other software projects. The component tested for development of rule-based knowledge base drafts for industrial safety expertise tasks.

ACKNOWLEDGMENT

The reported study was partially supported by RFBR (research project No. 18-07-01164, 18-08-00560, 19-07-00927).

REFERENCES

[1] W. P. Wagner, “Trends in expert system development: A longitudinal content analysis of over thirty years of expert system case studies”, Expert Systems with Applications, 2017, vol. 76, pp. 85–96.

[2] A. Yu. Yurin, N. O. Dorodnykh, O. A. Nikolaychuk and M. A. Grishenko, “Designing rule-based expert systems with the aid of the model-driven development approach”, Expert Systems, 2018, vol. 35, no. 5, pp. 1–23.

[3] S. Lukichev, A. Giurca, G. Wagner, D. Gasevic and M. Ribaric, “Using UML-based rules for web services modeling”, in the

Second International Workshop on Services Engineering, 2007, pp. 290–297.

[4] I. K. Faisal and S. A. Abbasi, “Analytical simulation and PROFAT II: a new methodology and a computer automated tool for fault tree analysis in chemical process industries”, Journal of Hazardous Materials, 2001, vol. 75, no. 1, pp. 23–56.

[5] E. J. Henley and H. Kumamoto, Reliability engineering and risk assessment. Prentice-Hall, Inc., Englewood Cliffs, N.J., 1981.

[6] H. Kumamoto, “CHAPTER 7 – Fault Tree Analysis”, Fundamental Studies in Engineering, 1993, vol. 16, pp. 249–311.

[7] RELEX Windchill FTA. (2018). [Online]. Available: http://www.relexsoftware.it/ptc-windchill/windchill-fta.

[8] Risk Spectrum. (2017). [Online]. Available: http://www.riskspectrum.com/en/risk.

[9] Systems Analysis Programs for Hands-on Integrated Reliability Evaluations (SAPHIRE). (2018). [Online]. Available: https://saphire.inl.gov.

[10] RAM Commander ETA V8.5. (2017). [Online]. Available: http://aldservice.com/Event-Tree-Analysis-ETA.html.

[11] Reliability Workbench incorporating FaultTree+. (2018). [Online]. Available: https://www.isograph.com/software/reliability-workbench/.

[12] CLIPS: A Tool for Building Expert Systems. (2017). [Online]. Available: http://www.clipsrules.sourceforge.net.

[13] A. Yu. Yurin, A. F. Berman, Dorodnykh, O. A. Nikolaychuk and N. Yu. Pavlov, “Fishbone diagrams for the development of knowledge bases”, in the 41st International Convention on Information and Communication Technology, Electronics and Microelectronics (MIPRO), 2018, pp. 1136–1141.

[14] K. Czarnecki and S. Helsen, “Feature-based survey of model transformation approaches”, IBM Systems Journal, 2006, vol. 45, no. 3, pp. 621–645.

[15] I. V. Bychkov, N. O. Dorodnykh and A. Y. Yurin, “Approach to the development of software components for generation of knowledge bases based on conceptual models”, Computational Technologies, 2016, vol. 21, no. 4. pp. 16–36. (in Russian).

[16] P. L. Clemens and R. J. Simmons, System Safety and Risk Management: NIOSH Instructional Module. A guide for Engineering Educators. Cincinnati,OH: National Institute for Occupational Safety and Health: IX-3–IX-7, 1998.

[17] A. F. Berman, O. A. Nikolaichuk, A. Yu. Yurin and K. A. Kuznetsov, “Support of Decision-Making Based on a Production Approach in the Performance of an Industrial Safety Review”, Chemical and Petroleum Engineering, 2015, vol. 50, no. 11–12, pp. 730–738.

[18] J-M. Flaus, “A model-based approach for systematic risk analysis“, Proceedings of the Institution of Mechanical Engineers, Part O: Journal of Risk and Reliability, 2008, vol.222, no.1, pp. 79-93.

[19] A.F. Berman, O.A. Nikolaychuk, A.Yu.Yurin and A.I. Pavlov, “A methodology for the investigation of the reliability and safety of unique technical systems“, Proceedings of the Institution of Mechanical Engineers, Part O: Journal of Risk and Reliability, 2014, vol. 228, no.1, pp.29-38.

[20] O.A.Nikolaychuk, “Automating studies of the technical state of dangerous mechanical systems“, Journal of Machinery Manufacture and Reliability, 2008, vol. 37, n.6, pp. 597-602.

[21] Ecore structure description (Metamodelling Language). (2018). [Online]. Available: http://download.eclipse.org/modeling/emf/emf/javadoc/2.9.0/org/eclipse/emf/ecore/package-summary.html.

[22] N. O. Dorodnykh and A. Y. Yurin, “A domain-specific language for transformation models”, CEUR Workshop Proceedings. Information Technologies: Algorithms, Models, Systems (ITAMS 2018), 2018, vol. 2221, pp. 70–75.

MIPRO 2019/CIS 1333