The Object-oriented Architecture of the Syntactic Pattern-recognition System Based on GDPLL(/c) Grammars 1
Janusz Jurek
Institute of Computer Science, Jagiellonian University, Nawojki 11, Cracow, 30-072 Poland
e-mail: jwj@ii.uj.edu.pl
Abstract. The syntactic patternrecognition model based onGDPLL(fc) grammars has been proposed [6, 13] as an efficient tool for inference supportin diagnosticand control expert systems. In this paper we dis
cuss thesoftware engineeringaspectof the syntactic pattern recognition (sub)system. Thearchitecture ofthe system should allow to embed the system in real-time environments, accumulate knowledge about theen vironment, and flexible react to the changes in the environment. The object-oriented approach has been applied to design the system, and the Unified Modeling Language has been used for the specification of the software model. In the paper we present themodel and its practical applications.
Keywords: syntactic pattern recognition, contextsensitive languages, parsing, grammatical inference, object-oriented approach, software en
gineering
1. Introduction
In the paper we describe the results of the research into application of a syntactic pattern recognition model in diagnostic and control expert sys
tems, especially real time expert systems. The model proposed is based on
’This work was supported by the Polish State Committee for Scientific Research (KBN) under Grant No. 3 T11C 054 26.
GDPLL(fc) grammars [6, 13], which have been introduced as an efficient tool for inference support in expert systems.
The research started several years ago for the purpose of diagnosing a behaviour of a big detector in a high energy physics experiment [3]. One of the main goals was to define an efficient method of the on-line analysis of patterns representing trend functions related to the performance of a very complex industrial-like equipment. The problem was difficult since the patterns have been highly complicated, and they had to be analysed on-line (diagnostic results have had to be given in real-time).
As it has been described in [6, 10], the problem can be solved via appli
cation of syntactic pattern recognition methods: the trend functions can be treated in an analogous way, as it is made while applying syntactic pattern recognition for ECG or EEG analysis [8]. The research into the problem has resulted in defining a new class of string grammars, DPLL(/c) grammars [6], and then ’’enhanced” GDPLL(fc) grammars [13]. GDPLL(fc) grammars, which are characterised by a big descriptive power (the grammars are stronger than context-free grammars), have been proved to be a suitable tool to de
scribe the trend functions. On the other hand, it has appeared that it is possible to define an efficient, O(n), parser for GDPLL(fc) grammars [10]. A construction of the parser of linear computational complexity has been an important achievement because computational time is a crucial factor if we consider applications in real-time systems.
During past two years we have been verifying the possibility of practical use of the model in several different application areas. The model has been successfully embedded in an expert system for evaluating organs of hearing in neonates in electric response audiometry [7] (a common project led by Chair of Applied Computer Science, Jagiellonian University, and Otolaryngological Clinic, Jagiellonian University Medical College). Now, the model is tested for the application as a part of an on-line expert system running at the Polish Power Grid Company, one of the biggest companies in Poland which is responsible for the whole Polish power system [12].
Although we have already achieved very good results of the research, the
’’theoretical” model of GDPLL(A:) grammars and parsers is still being devel
oped. One of the most recent results is the construction of a grammatical inference algorithm (i.e. an algorithm of automatic construction of a gram
mar from the sample of a pattern language [8]) for GDPLL(fc) grammars.
The algorithm has been presented in [14] and in this way we have solved a problem of syntactic pattern learning in case of this class of grammars.
After establishing the pattern recognition ’’theoretical background”, new research, software engineering related, has been started. The research has been aimed at developing an efficient software architecture model for the pattern recognition formalisms. In order to fulfil strong requirements of the
applications mentioned above (i.e. real-time expert systems for the physics experiment, the real-time expert system for the Polish Power Grid, and the expert system for the medical diagnostic), it has been necessary to design a proper architecture of the system that should guarantee: high efficiency, the accumulation of the knowledge about the environment, and the flexible reaction to the changes in the environment.
The methodological studies and practical experiments have resulted in the development of the object-oriented architecture of the system (according to the Booch methodology [4]). The Unified Modeling Language [5], UML, has been used for the specification of the software model.
In the paper we discuss the architecture of the system and the practical applications. In the next section we quote a few basic definitions related to GDPLL(A:) grammars. In section 3 the outline of the syntactic pattern recognition system is presented. Section 4 contains the specification of the object-oriented model of the system. The applications of the system are considered in section 5. Concluding remarks are included in the final section.
2. Basic definitions
Let us introduce a few basic definitions [6, 13] needed to discuss the software architecture of the syntactic pattern recognition system.
Definition 1. A generalised dynamically programmed context-free grammar is a six-tuple
G = (V,S,O,P,S,M) where:
V is a finite, nonempty alphabet;
L C V is a finite, nonempty set of terminal symbols (with N we denote a set of nonterminal symbols N = V \ S);
O is a set of basic operations on the values stored in the memory (as
signment, addition, subtraction, multiplication);
S 6 N is the starting symbol;
M is the memory (the memory is defined as such a memory structure that integer numbers can be stored in it and each element of the memory
can be accessed in a constant time — for example the memory could be built of several named integer variables or the memory could be a multidimensional array of integer variables);
P is a finite set of productions of the form:
Pi = (Mt, Li, Ri, Ai) in which:
Hi : M —> [TRUE, FALSE} is the predicate of applicability of the production pi defined with the use of operations (G 0}
performed over M;
Li G N and Ri G V* are left- and right-hand sides of pi, respec
tively; a pair (Li, Ri} will be called a core of pp,
Ai is the sequence of operations (6 0} over A/, which should be performed if the production is to be applied. □
A derivation for generalised dynamically programmed grammars is de
fined in the following way. Apart from testing whether Li occurs in a senten
tial form derived, we check the predicate of applicability of a production pj.
The predicate in generalised dynamically programmed grammars is defined as an expression based on variables stored in the memory. The evaluation of the predicate can need some calculations over integer values. If the predicate is true, we replace Li with Ri and then we perform the sequence of operations over the memory. The execution of the operations changes the contents of the memory (memory variables). It is done with the help of arithmetical and assignment instructions.
Definition 2. Let G = (V, S, O, P, S, M} be a generalised dynamically programmed context-free grammar. The grammar G is called a Generalised Dynamically Programmed LL(k) grammar, GDPLL(A:) grammar, if the fol
lowing two conditions are fulfilled.
1. Let w E D*, A G N = V \E, x,y,a, /3,^ G V*. Then, for every two left-hand side derivations in G:
S ——► wAa---► w/3a ——- wx1 core S ——- wAa--- - wya ——- wyI core
such, that: Fir st *,(r) = Firstly), the following condition holds:
V = 7-
2. For a grammar G there exists a certain number £ such, that for any left
hand side derivation S—^—>~wAa—?—-wßa (where w G S*, A E N, a,ß E V*) fulfilling a condition : |7r| > the first symbol of ßa is the terminal one.
( G ► denotes a single derivation step in G; —► denotes the tran
sitive and reflexive closure of G <• ; G ► denotes such a derivation, which consists in application of succeeding productions from 7r, where 7r is a string of indices of productions; G---- «- denotes such a single derivation step that consists in an application of only a production core as a rewriting rule;
G * ► denotes the transitive and reflexive closure of G---- ►; Firstfßx') is a simple extension of a First^x) notation used for LL(fc) grammars [16].) □
Fig. 1. A use case diagramofthe syntactic pattern recognitionsystem
3. Outline of the syntactic pattern recognition system
There are two main tasks which are to be performed by the syntactic pattern recognition system based on GDPLL(fc) grammars:
• inferencing a GDPLL(A:) grammar, and
• recognising a pattern generated by a given GDPLL(fc) grammar.
The tasks are shown as use cases in Fig. 1.
Grammatical inferencing is a very important aspect of the syntactic pat
tern recognition system functioning. One of the main problems of practical applications of the GDPLL(fc) grammars consists in difficulties in defining the grammar from the sample of a pattern language. Therefore, a gram
matical inference algorithm is needed to automate a very complex process of constructing suitable grammars. The problem of grammatical inferencing is a well-known issue in the syntactic pattern recognition area. There are many approaches and methods developed since seventies [8, 17, 9]. Never
theless there is still lack of general models of inferencing context-sensitive grammars since inference algorithms have been constructed only for some particular subclasses of context-sensitive languages and grammars [2]. The generative power of GDPLL(fc) is ’’almost” as big as context-sensitive gram
mars, and the development of a method of grammatical inference for this kind of grammars [14] is of big importance.
The use case diagram in Fig. 1 shows two actors: User and Input device.
Input device represents a hardware or software system that delivers patterns which should be analysed and recognised, while User represents the human operator of the syntactic pattern recognition system. Although grammatical inferencing assumes automatical defining the grammar from the sample of a pattern language (the sample is delivered by Input device), our practical ex
periences prove that the user should always verify and improve the definition of the GDPLL(fc) grammar being the product of the inference algorithm.
After defining a GDPLL(A:) grammar, the system is ready to perform recognition of patterns provided by Input device. The recognition is made via syntax analysis of patterns, i.e. a pattern is analysed by a parser correspond
ing to a given GDPLL(A:) grammar. The results of the analysis are presented to User.
4. Object-oriented model of the system
The analysis and design of the software architecture of the syntactic pattern recognition system has been done according to the object-oriented methodology [4]. Firstly, the main (at the top-level of abstraction) classes and objects have been identified. Let us consider the diagram shown in Fig. 2.
Fig. 2. A class diagram of Grammar
Class Grammar is responsible for storing the complete definition of a GDPLL(/c) grammar G = (V, E, O, P, S, M) (see Section 2).
Class Symbol table stores all names of terminal symbols (E) and nonter
minal symbols (TV = V \ E). The symbols will be represented to the rest of the system (i.e. all other classes) by integer numbers. A number assigned to a given symbol is the array index indicating the place where the name of the symbol can be found in Symbol table class.
Class Production is used to store the specification of a single production in grammar G. This class contains the information about the core of the production (L,R pair), its predicate of applicability (¿z), and the sequence of operations (A) which should be performed when the production is to be applied.
Symbol table class as well as Production classes are aggregated in Gram
mar class. The aggregation is of a ’’strong” form (called composition in UML) because the lifetime of Symbol table and Production objects strictly depends on the lifetime of Grammar object.
Now, let us consider the classes corresponding to Grammatical Inference use case (see Section 3). The classes are shown in Fig. 3.
Fig. 3. Aclass diagramof Grammatical Inference: the context
Input/output Grammatical Inference
There are two classes shown in the diagram above: Input/output class and Grammatical Inference class. Input/output is responsible for the communica
tion between the system and ’’the outside world”, while Grammatical Inference is responsible for the automatic generation of a GDPLL(/c) grammar from the sample of a pattern language.
Class Input/output is a utility class, i.e. it is not a real class defined accord
ing to the object-oriented paradigm, but only a convenient construct used for grouping global variables and procedures in the form of a class declaration.
Input/output is associated with Grammatical Inference, since Input/output de
livers the sample of a pattern language, and provides user interface for veri
fication of the grammar produced by the Grammatical Inference.
The structure of Grammatical Inference class is shown in Fig. 4. Gram
matical Inference aggregates a class Polynomial Specification, and Polynomial Specification includes several Polynomial Structure classes.
Fig. 4. A classdiagramof Grammatical Inference: associated classes Classes: Polynomial Specification and Polynomial Structure have been de
fined in the model because of the method of grammatical inferencing. The method assumes dividing the inference process into three phases:
1. The first phase is responsible for extraction of the features of the sam
ple, and generalisation of the sample. A so-called polynomial specifica
tion of the language is obtained as the result of the phase.
2. In the second phase the polynomial specification of the language is verified and refined by the human user of the grammatical inference system.
3. In the third phase, a GDPLL(k) grammar is generated on the basis of polynomial specification of the language.
All phases are independent of each other. The third phase is well-defined, i.e. the result of this phase is strictly determined by the input data (a poly
nomial specification of the language). On the contrary, the first phase is not well-defined since there may be many approaches to the generalisation of the sample and the ” quality” of an approach depends on a particular application and a particular sample of the language. That is why the second phase is needed: our practical experiences prove that the user should always verify and improve polynomial specification of the language (automatically produced) before it is used for generation of the suitable GDPLL(A?) grammar.
The detailed description of the grammatical inference method can be found in [14]. Nevertheless, let us present here the definition of the poly
nomial specification of the language and the polynomial structure, since the definitions are needed to understand the structure and role of Polynomial Specification and Polynomial Structure classes.
Definition 3. Let A be a set of all (terminal) symbols which appear in the sample, N be a set of integer variables. Polynomial specification of a language is of the form:
Lp(A,N) = S?M
where: pj is a polynomial of a variable € AT; variable can be assigned only values greater or equal 1 (n^ > 1); Si, called a polynomial structure, is defined in a recursive way:
1) Si = (aij-.-aiJ, where G A
(Si is called a basic polynomial structure) or
2) Si = (5P'1^n‘1\..5lPr‘r^n”'^), where Sik is defined as in 1) or 2).
(Si is called a complex polynomial structure.) □
Example 1. Let A = {a, b, c} be a set of terminal symbols, N = {n, m}
be a set of integer variables. Then:
LP(A,N) = ((ab)2n+lcn2(baYmy)n+2(ab)m3
is an example of polynomial specification of a language. The polynomial structures in the specification are the following:
5i = ((ab)2n+1cn2(6a)2m)n+2(a6)m3 Pi - 1
5h = (ab)2n+icn2 (ba)2m Pii(n) = n + 2
S12 — ûô Pi2(m) = m3
Sijj = ab PiijW = 2n + 1
sh2 = c Pii2(n) = n2
S] •« — l)CL
1]3___________________________ Ph^(m) = 2m
One can easily notice that polynomial structures create a tree structure.
Therefore Polynomial Specification class should be designed and implemented to reflect the structure. □
As it has been shown in Fig. 4, Grammatical Inference class is associated with Grammar class. The association illustrates the fact that a Grammatical Inference object creates a Grammar object. The creation can be interpreted as:
• the physical creation of the new object in the system (the allocation of the memory and execution of an object’s constructor) or
• the initialisation of all data structures (attributes) of existing Grammar object.
Both interpretations are correct, and the choice of the one of them depends only on programming preferences.
The scenario of the grammatical inference is shown as the sequence di
agram in Fig. 5. Let us notice that for each class mentioned above there is only one instance (object) of this class, so we can use classes’ names to identify objects participating in the scenario.
The sequence diagram in Fig. 5 reflects the way in which grammati
cal inference is performed. The three phases of grammatical inference are
’’executed” by messages:
• phase 1: generate_polynomial_spec()
• phase 2: refine_polynomial_spec()
• phase 3: generate_grammar()
The result of the grammatical inference scenario is a GDPLL(fc) gram
mar specification. This means that the :Grammar object is created and all its attributes are initialised with proper values.
Now, let us consider the classes corresponding to Pattern Recognition use case (see Section 3). The classes are shown in Fig. 6.
: Input/output Grammatical Inference
Polynomial Specification
Grammar
Fig. 5. A sequence diagram ofthe grammatical inference
Fig. 6. A class diagram of Parser: the context
Input/output I Parser
Similarly to Fig. 3, there are two classes shown in the diagram above:
Input/output class and Parser class. The role and responsibilities of In- put/output in the system have been already described. Parser class is re
sponsible for the syntax analysis of a pattern delivered by Input/output.
Classes associated with Parser class are shown in Fig. 7. Parser uses Grammar, Production, Symbol Table classes. The scenario of collaboration between the classes will be presented subsequently.
The structure of Parser class is shown as a class diagram in Fig. 8. Parser aggregates three classes: Stack, Interpreter, and Control Table. All of them are presented in the class diagram.
Class Stack represents a standard stack structure. It is exactly the same as the stack structure used in parsers for context-free grammars [1]. Let us notice that the ’’core” of the GDPLL(fc) parser is very similar to the
’’ordinary” LL(fc) parser [10].
1? /(..*
Prediction Parser uses all
associated classes
Fig. 7. A class diagram of Parser: associated classes
Fig. 8. A class diagram ol Parser: aggregated classes
Class Control Table contains the specification of the transition functions of the GDPLL(fc) parser. Control Table can be described as a two-dimensional
array indexed by: the current input symbol (or lookahead string if k > 1), and the top element of the stack. Each cell of the array stores information about what the parser should do in a configuration specified by the input symbol and the stack. The action to be performed is one of the following:
• Remove: if the input symbol has been already derived. In this case the top element of the stack should be removed, and the next symbol should be read by the input device.
• Error: if it is impossible to derive the input symbol. In such a situation the parser should write an error message to the output and finish its work.
• Apply Production: if the parser should apply a production to derive the input symbol. In this case the array cell contains additional informa
tion about all productions possible at the derivation step. The parser should choose out of possible productions the only one which is to be applied. This production should be is chosen via checking the predi
cates of applicability of possible productions. Then the parser should change the contents of the stack according to the information stored in the array cell, and finally it should change the memory executing operations corresponding to the production applied.
Class Interpreter is responsible for reading and changing the memory (M).
Let us point out that the definition of a production in a GDPLL(fc) gram
mar (see Definition 1) contains four elements: pi = (pi, Li, Ri, Ai). Function Pi : M —> {TRUE, FALSE} is the predicate of applicability of the pro
duction pi defined with the use of operations (<£ O) performed over M, and Ai is the sequence of operations (e O) over M, which should be performed if the production is to be applied. M is the common (for all productions in a grammar) memory. Interpreter is responsible for both: evaluating the predi
cate of applicability of a production, and executing operations corresponding to a production.
As it has been illustrated in Fig. 8, class Interpreter aggregates Memory class. Memory class is related to the memory M from a GDPLL(A:) grammar definition. According to the general definition, the memory is such a memory structure that integer numbers can be stored in it and each element of the memory can be accessed in a constant time; for example the memory could be built of several named integer variables or the memory could be a multi
dimensional array of integer variables. In our model we suggest design and implementation of three different memory structures represented by three different classes:
• Variable Table class that is responsible for storing named integer vari
ables.
• Array class which is a two-dimensional array of integer variables.
• FIFO Queues class that is responsible for storing FIFO (first-in, first
out) queues, corresponding to the derivation control lists (DCL tapes) from the definition of DPLL(fc) grammars (predecessors of GDPLL(fc) grammars [6]).
Our practical experiences with GDPLL(/c) grammars have shown that such three memory structures are powerful enough to conveniently construct GDPLL(A:) grammars describing even very complicated patterns.
Having all the classes related to the Pattern recognition use case described, let us present the scenario of the pattern recognition. The scenario is shown as the sequence diagram in Fig. 9. Let us notice that in the diagram classes’
names identify objects participating in the scenario because for each class there is only one instance (object) of this class.
The sequence diagram in Fig. 9 reflects the parsing method. In [6] the parsing method has been described on the basis of the automata formalism.
The sequence diagram shows how an object-oriented software system can use the method. Let us consider main messages passed between objects:
• derive_one_symbol() message is sent by :lnput/output to :Parser for each symbol in the analysed string pattern.
• find(top,index) message is sent by :Parser to :Control Table. It returns the information about what the parser should do in a configuration specified by the input symbol and the top element of the stack (the types of the possible parser actions has been specified above).
• validate_production() message is sent by :Parser to interpreter for each production possible in a derivation step. The message is responsible for choosing out of all possible productions the only one which is to be applied. The proper production is chosen via checking the predicates of applicability of possible productions.
• perform_operations() message is sent by :Parser to interpreter for all op
erations corresponding to the applied production, interpreter programs future derivations steps by changing the contents of the memory.
The result of the scenario is the classification of a pattern which can be additionally commented and interpreted on the basis of the productions used during the derivation of the pattern.
: Input/out put J 1 : Symbol Table 1 :Paner 1
1... . „
: Stack :Control Table i : Interpreter : Memory
1
r find-index (sy mbol )
I ;
j derne_one_symbol(index)
1 ■ ' •
i called for ell i symbols in i the pattern
! string
ta8t=stack_errp(y() ;
=
top=stack_lop()
1
find (top.index) '... -... ...
veiUate_production()
remove_s lack_lop()
called for all 1 productions which are possfole; returns the only one vtfiich is to be applied
read_memory()
■
eveluate_pred>cate()
add_stack_top()
peiform_operations()
called for aN operations corresponding to the applied production
^calculate_\alue()
! i<...
¡change_memary() I ... >
i
Fig. 9. A sequence diagram of the pattern recognition
The object-oriented model presented in the paper has been practically verified. It has been used for the implementation of the syntactic pattern recognition (sub)system in several applications described in next section. The algorithmic ’’core” of the system has been implemented in C++ language, while some different user interfaces have been prepared with tools dependent on the system environment (e.g. RTworks shell has been used in case of a unix server platform; Microsoft Windows libraries has been used in case of a PC platform).
The proposed object-oriented model allow to embed the system in real
time environments (it is computationally efficient), and to accumulate knowl
edge about the analysed phenomena (with the use of the grammatical infer
ence functionality). The model is flexible: it can be easily enhanced (for example by adding new memory structures or new operations) in case of some special requirements of a given application.
It is also worth to point out that the model allows to design and implement a multi-agent system [11]. GDPLL(fc) parsers constructed according to the model can be embedded in reactive agents of syntactic pattern recognition
type. It is possible to implement several parser-based agents, where each agent is responsible for analysis of a different characteristics of the environ
ment being monitored.
5. Applications
The software model presented in previous sections has been developed for the purpose of syntactic pattern recognition-based expert systems. As we have mentioned in the introduction, there are several different application areas of the model. Let us briefly discuss them in this section.
The first application area of the syntactic pattern recognition system is monitoring and diagnosing of industrial-like equipment in real-time. An example of such an application is the ZEUS Expert System, called ZEX [3]
. ZEX is a real-time control expert system, designed at the Deutsches Elektronen-Synchrotron, Hamburg, Germany, with the help of the real-time expert system building shell RTworks from Talarian. The system monitors and makes diagnoses of various aspects of work of the ZEUS detector2, in
cluding monitoring detector electronics, data acquisition computers, data flow processes. ZEX is also able to react when it detects errors, and perform suitable actions to eliminate them (e.g. it alerts the shift crew and gives them instructions about what should be done).
2The ZEUS detector consists of more than 20 various subdetectors. Its dimensions are 12 m x 10 m x 19 m and its total weight is 3600 tons. It is located about 20 m deep under ground at the 6.3 km long accelerator tunnel. It is operated by a collaboration of about 450 scientists coming from more than 50 institutions in 11 countries.
We have applied the syntactic pattern recognition system in ZEX to sup
port diagnosing the Data Acquisition System (the DAQ subsystem). The syntactic pattern recognition system monitors critical characteristics of the components of the DAQ system: processing times, available memory space, data throughput, interface memory buffers, and gives a diagnosis in case of problems. A fragment of an example display in ZEX is shown in Fig. 10. The chart in Fig. 10 graphically illustrates changing of the loads of some buffers belonging to components of the DAQ system. Such charts (trend functions) are analysed with the use of GDPLL(fc) grammars and parsers.
Internal buffer load vs. time
Fig. 10. A fragment of an example display in the ZEUS Expert System
Fig. 11. An exampledisplayin the expert system for the purpose ofmedical diagnostics
The second application area of the model of the syntactic pattern recogni
tion system is medical diagnostics. The model has been successfully applied in an expert system for evaluating organs of hearing in neonates in electric response audiometry, ERA [7]. An example of a window in the GDPLL(fc) parser module is shown in Fig. 11. The audiometry charts presented are anal
ysed in a similar way as it is done while applying syntactic pattern recognition for ECG [15].
Let us notice that this application has proved the practical need of the implementation of the grammatical inference algorithm for GDPLL(/c) gram
mars. Medical symptoms in ERA are highly sophisticated and it is very dif
ficult to define a suitable GDPLL(A:) grammar without any software support.
Now, the model is tested for the application in a real-time expert system running at the Polish Power Grid Company for the analysis of the electrical load [12]. An example of electrical load diagrams which are to be analysed by the syntactic pattern recognition system is shown in Fig. 12. Let us stress that the application in the Polish Power Grid Company is characterised by very strong requirements and the reaction time is especially important.
Fig. 12. An example of electrical load diagrams
6. Concluding remarks
In the paper we have presented the model of the object-oriented architec
ture of the syntactic pattern recognition system based on GDPLL(/c) gram
mars.
The syntactic pattern recognition system can be used as an efficient tool for inference support in diagnostic and control expert systems. The applica
tion areas of the system include: real-time monitoring and diagnosing of a
behaviour of a very complex industrial-like equipment, medical diagnostics, and real-time analysis of electrical load trends for the power industry.
The object-oriented model presented in the paper has been practically verified. It has been used for the implementation of the syntactic pattern recognition system in several applications. The model is computationally ef
ficient, it allows to analyse very complex phenomena and accumulate knowl
edge about them (in the form of GDPLL(fc) grammars).
Because of the use of object-oriented methodology, the model is flexible, easily maintainable, and can be effortlessly enhanced to satisfy requirements of possible more sophisticated applications.
7. References
[1] Aho A.V., Ullman J.D.; The Theory of Parsing, Translation, and Compiling, Prentice-Hall,Englewood Cliffs, NJ, 1972.
[2] Alquezar R.,Sanfeliu A.; Recognition and learning ofa class of context-sensitive languages described by augmented regular expressions, Pattern Recognition, 30,1, 1997, pp. 163-182.
[3] Behrens U., Flasihski M., Hagge L., Jurek J., Ohrenberg K.; Recent develop ments of the ZEUS expert system ZEX, IEEE Trans. Nucl. Sci., NS-43, 1996, pp. 65-68.
[4] Booch G.; Object-OrientedAnalysis and Design with Applications, Second Edi
tion, The Benjamin/Cummings Publishing Company, 1994.
[5] BoochG., Rumbaugh J.,JacobsonI.; The Unified Modeling Language Reference Manual, Addison-Wesley, 1999.
[6] Flasinski M., Jurek J.; Dynamically Programmed Automata for Quasi Context Sensitive Languages as a Tool for Inference Support in Pattern Recognition- Based Real-Time Control Expert Systems, Pattern Recognition, 32,4, 1999, pp.
671-690.
[7] Flasinski M., Reron E., Jurek J., Wojtowicz P., Atlasiewicz K.; Mathematical linguistics model for medical diagnostics of organ of hearing in neonates, Lec ture Notes inComputerScience (LectureNotes in Artificial Intelligence), 3019, 1994.
[8] Fu K.S.; SyntacticPattern Recognition andApplications, PrenticeHall, Engle wood Cliffs, 1982.
[9] Higuera De La C.; Current Trendsin Grammatical Inference, Lecture Notes in Computer Science, 1876, 2000, pp. 28-31.
[10] Jurek J.; On the Linear Computational Complexity of the Parserfor Quasi Context Sensitive Languages, Pattern Recognition Letters, 21, 2000, pp. 179— 187.
[11] Jurek J.; Syntactic Pattern Recognition-Based Agents for Real-Time Expert Systems, LectureNotes inComputer Science (LectureNotes in Artificial Intel ligence), 2296, 2002, pp. 161-168.
[12] Jurek J., On the constructionofhybridexpertsystems for the application inthe power industry, (Paper in Polish) Proc. 5th National Conf. ’’Inżynieria Wiedzy i Systemy Ekspertowe”, Wrocław,Poland, June 11-13, 2003, 2, 2003, pp. 54-61.
[13] Jurek J.; The Generalised Model ofDPLL(k) Automata for Applications in Real-Time Expert Systems, Proc. 3rdConf.On Computer Recognition Systems, KOSYR’03, Miłków, Poland, May 26-29, 2003, 2003, pp. 321-326.
[14] Jurek J.; Towards grammatical inferencing of GDPLL(k) grammars for ap plications in syntactic pattern recognition-based expert systems, submitted for ICAISA 2004: 7th InternationalConf.On Artificial Intelligence And Soft Com puting, Zakopane, Poland,June 7-11, 2004.
[15] Piętka E.; Feature extraction in computerized approach to the ECG analysis, PatternRecognition, 24,2, 1991, pp. 139-146.
[16] Rosenkrantz D.J., Stearns R.E.; Properties of deterministic top-down gram
mars, Information and Control, 17, 1970,pp. 226-256.
[17] SakakibaraY.; Recent Advances of Grammatical Inference, Theoretical Com puter Science, 185,1, 1997, pp. 15-45.
Received February 11, 2004
