A framework for knowledge-based systems verification

The readability of formal requirements specification languages is hypothesized as a limiting factor in the acceptance of formal methods by the industrial community. An empirical study was conducted to determine how various factors of state-based requirements specification language design affect readability using aerospace applications. Six factors were tested in all, including the representation of the overall state machine structure, the expression of triggering conditions, the use of macros, the use of internal broadcast events, the use of hierarchies, and transition perspective (going-to or coming-from). Subjects included computer scientists as well as aerospace engineers in an effort to determine whether background affects notational preferences. Because so little previous experimentation on this topic exists on which to build hypotheses, the study was designed as a preliminary exploration of what factors are most important with respect to readability. It can serve as a starting point for more thorough and carefully controlled experimentation in specification language readability.

The Live Sequence Charts (LSC) language is a formally rigorous variant of the well-known scenario language Message Sequence Charts (MSC). LSCs yield expressive power by means to distinguish mandatory and scenario behaviour, means to characterise by another scenario the context in which a specification applies, and means to distinguish required from possible progress, i.e. to require liveness. From the original proposal by Damm & Harel [1], two slightly different dialects emerged, one in the context of LSC play-in and -out [2] and one for the use of LSCs as formal requirements specification language in formal, model-based approaches to software development [3]. In this paper, we investigate the expressive power of LSCs in the sense of [3]. That is, we first (constructively) show that for each LSC there is an equivalent CTL * formula. Complementing existing work, we show that the containment is strict, that is, not each CTL* formula has an equivalent LSC. To complete the discussion, we present for the first time a way back, from a syntactically characterised fragment of CTL* to the subset of bonded LSC specifications, thereby establishing an equivalence.

Dutch research on knowledge-based instructional systems: Introduction to the special issue

The relationship between errors and size in knowledge-based systems

On the validation and verification of production systems: a graph reduction approach

Requirements Engineering is more and more considered as a central phase in the development and implementation of computer systems. Within the context of CIM, the CIMOSA project proposes a set of models based on adequate concepts for expressing requirements. In this paper, we suggest how these models can be supported by the use of a fully formal requirements specification language called ALBERT and based on an agent-oriented real-time temporal logic framework.

Knowledge-based Systems and Expert Systems, in particular, are expensive to build and difficult to validate and debug because of their complexity and dynamism. Therefore, it is not easy for knowledge engineer and domain expert to identify the gaps and mistakes in knowledge base. Unit testing is unable to cover validation process at all stages, in many cases manual thorough review of decision process is needed. In this paper we spot main approaches to validation and verification issue and describe a component that helps to debug a knowledge base by visualising execution of rules that derive a particular result. This component is developed for Knowledge-based Systems built on Drools Platform1 and we demonstrate application of this component in a knowledge-based engineering system for structural optical design.

Knowledge-based systems verification: A machine learning-based approach

Progress in software engineering has led to system development following models of the system life cycle. These models incorporate the use of prototyping and formal methods of program verification. They are becoming supported by integrated project support environments and permit the planning and monitoring of software development projects.In contrast, knowledge based systems (KBS) are developed using informal views of the system life cycle. Tools have been developed to support some stages of the life cycle in an undisciplined manner. The commercial use of KBS needs development projects to be planned and monitored. This requires methods and tools based on systematic life cycle models to be established for KBS.This paper reviews the current state of life cycle approaches to software engineering and KBS development projects in order to provide a direction for the development of methodical KBS life cycle models.

The complexity of designing concurrent and highly-evolving interactive systems has grown to a point where system verification has become a hurdle. Fortunately, formal verification methods have arrived at the right time. They detect errors, inconsistencies and incompleteness at early development stages of a system formally modeled using a formal specification language. -calculus (Milner, 1999) is one such formal language which provides strong mathematical base that can be used for verifying system specifications. But manually verifying the specifications of concurrent systems is a very tedious and error-prone work, especially if the specifications are large. Consequently, an automated verification tool would be essential for efficient system design and development. In addition, formal verification tools are vital ingredient to fully harness the potential of component-based software composition. The authors developed such an automated verification tool which is highly portable and seamlessly integrates with the visualization, reduction and performance evaluation tools introduced (Ahmad & Rahimi, 2008; Rahimi, 2006; Rahimi et al., 2001, 2008) to provide a comprehensive tool for designing and analyzing multi process/agent systems. Open-Bisimulation (Sangiorgi, 1996) concept is utilized as the theoretical base for the design and implementation of the tool which incorporates an expert system implemented in Java Expert System Shell (JESS) (Friedman-Hill, 2003).

Formal software development begins with formal specification of the user requirements or design of a system. Hence, formal specification languages are used to resolve ambiguities in user requirements or detect design errors at the early software life cycle. Furthermore, specification-based functional testing derives test inputs from its formal specification. However, formal specifications are expressed using set theory or predicate logics which are non-executable. Thus, functional test execution over abstract expressions would be impossible. Therefore, there is a need to refine abstract specification into a form that can be executable. In this paper, an automatic functional testing framework using object constraint language (OCL) formal specification has been proposed. The major objective of this paper is to describe how the refinement processes are integrated into the specification-based testing framework.

Traditional structured analysis and design methods have been criticized because the methods lack formality to provide a design for rigorous development. Several approaches have been developed for verifying a design by integrating traditional structured analysis and design methods with formal specification languages. However, the integration of traditional structured analysis and design methods with formal specification languages may confuse the problem definition and understanding with the attempt to define system structures and algorithms in the design phase. In addition, formal specification languages may add complexity to the design due to the complexity of the language syntax and semantics. In this paper, we are presenting an approach to verification of a structured design in HOS without using formal specification languages. Rules for the partial and total correctness of the design are also discussed.

Part 1 Putting knowledge-based systems in context: artificial intelligence - a brief overview knowledge-based systems other fruits of AI research an applications point of view differences between KBS's and conventional computer systems. Part 2 Knowledge-based systems - a solution in search of a problem?: what sort of problems may be addressed using KBS's what factors determine an application's suitability for a KBS approach? operational KBS's the key features of KBS construction. Part 3 KBS/AI concepts and tools: KBS concepts tools used to build KBS's - an overview knowledge acquisition knowledge representation system execution - for the knowledge engineer system execution - for the end-user maintenance. Part 4 Conventional software engineering: why are structured development methods relevant to KBS's? the conventional systems development life-cycle (SDLC) and formal methods extensions to the SDLC prototyping for decision support systems prototyping for non-DSS's contrasting features of DP and KB system development prototyping in KBS development. Part 5 ORSA methodology: why worry about the business objectives? what is operational research? a soft OR methodology soft systems methodology soft methodologies in general. Part 6 Lessons from other KBS work: current KBS development methodology - the textbook view AI methodology compared with DP methodologies a project management perspective. Part 7 The Intellipse experience: the original project specification - the main project phase the key changes to the proposal the concept of Intellipse functional specification the task compraring SSD Intellipse architecture knowledge bases is SSD a suitable domain for KBS's? advisor designer. Part 8 Measuring the success of a knowledge-based system : Why measure the success? what needs to be done? how to measure the success-sources of inspiration how to measure the success of a KBS-our recommendations. Part 9 A methodology for the practical engineering of knowledge-based systems: a POLITE engineering methodology for KBSs' standards for the POLITE methodology-the ITAM investigation POLITE in action.

The development of a knowledge-based software package for the analysis and control of electric distribution networks is discussed. A relational knowledge base, implemented in Prolog, is used to insure fast access to the data and an efficient post-reconfiguration update algorithm. An expert system shell DECIDE, is used to interpret human knowledge coded as knowledge clusters, and to provide a menu-driven user interface. The knowledge-based system described here has the following advantages: its expert system shell provides 'backup' and 'explanation' facilities; it can generate all the possible network reconfigurations and recommend the best choice; and the Prolog implementation of the algorithms is easy to maintain. The knowledge base is easy to expand and can be modified during execution. The prototype system demonstrates that artificial intelligence techniques can be used in power system analysis and reconfiguration, and provides a platform on which a base future research on the utility of expert system technology in distribution automation. >

In Wide Area Networks (WANs)inconsistencies among the security policies of Administrative Domains (ADs) may cause severe security flaws. Recently, security policies are written in natural language and as they get more complicated, even for an expert it might be impossible to detect such inconsistencies. However, when a formal language is used, it might be possible to make verification of security policies by automated theorem proving tools. Due to the existence of mobile devices such as laptops, PDAs and mobile agents, we need a formal language that is capable of defining the concept of mobility. In this paper, we extend Mob adtl [1] according its refinement methodology to obtain a formal policy specification language for an 802.11 WLAN with enhanced security network.