PROLOG META-INTERPRETERS FOR RULE-BASED INFERENCE UNDER UNCERTAINTY

Uncertain facts and inexact rules can be represented and processed in standard Prolog through meta-interpretation. This requires the specification of appropriate parsers and belief calculi. We present a meta-interpreter that takes a rule-based belief calculus as an external variable. The certainty-factors calculus and a heuristic Bayesian belief-update model are then implemented as stand-alone Prolog predicates. These, in turn, are bound to the meta-interpreter environment through second-order programming. The resulting system is a powerful experimental tool which enables inquiry into the impact of various designs of belief calculi on the external validity of expert systems. The paper also demonstrates the (well-known) role of Prolog meta-interpreters in building expert system shells.Information Systems Working Papers Serie

Third Conference on Artificial Intelligence for Space Applications, part 2

Topics relative to the application of artificial intelligence to space operations are discussed. New technologies for space station automation, design data capture, computer vision, neural nets, automatic programming, and real time applications are discussed

MELT - a Translated Domain Specific Language Embedded in the GCC Compiler

The GCC free compiler is a very large software, compiling source in several languages for many targets on various systems. It can be extended by plugins, which may take advantage of its power to provide extra specific functionality (warnings, optimizations, source refactoring or navigation) by processing various GCC internal representations (Gimple, Tree, ...). Writing plugins in C is a complex and time-consuming task, but customizing GCC by using an existing scripting language inside is impractical. We describe MELT, a specific Lisp-like DSL which fits well into existing GCC technology and offers high-level features (functional, object or reflexive programming, pattern matching). MELT is translated to C fitted for GCC internals and provides various features to facilitate this. This work shows that even huge, legacy, software can be a posteriori extended by specifically tailored and translated high-level DSLs.Comment: In Proceedings DSL 2011, arXiv:1109.032

META-INTERPRETERS FOR RULE-BASED REASONING UNDER UNCERTAINTY

One of the key challenges in designing expert systems is a credible representation of uncertainty and partial belief. During the past decade, a number of rule-based belief languages were proposed and implemented in applied systems. Due to their quasi-probabilistic nature, the external validity of these languages is an open question. This paper discusses the theory of belief revision in expert systems through a canonical belief calculus model which is invariant across different languages. A meta-interpreter for non-categorical reasoning is then presented. The purposes of this logic model is twofold: first, it provides a clear and concise conceptualization of belief representation and propagation in rule-based systems. Second, it serves as a working shell which can be instantiated with different belief calculi. This enables experiments to investigate the net impact of alternative belief languages on the external validity of a fixed expert system.Information Systems Working Papers Serie

The Development, Management and Support of Smart Strategic Alliances

Despite the increasing number of strategic alliances, how to ensure their success is poorly understood. Studies suggest that up to seventy-five percent of alliances fail to meet their initial objectives due to a multitude of cultural, political, technological and human factors. If such an eclectic set of competencies is required for success, alliance management is clearly a difficult task for today’s manager. Traditionally, managers wishing to develop strategic alliance competencies have relied on ad-hoc consultancy services and training. This has not, to date, resulted in a notable improvement in alliance success. The SMART project redresses this growing need by developing a knowledge-based software support system to help managers conceptualise, implement and manage strategic alliances. First, this paper introduces the field of strategic alliances; then the foundations of knowledgebased support systems are discussed. Finally, how the SMART approach will create value for managers is relayed

A preliminary philosophy for ARCTURUS : an advanced highly-integrated programming environment

At Irvine, we are currently in the initial stages of designing a programming environment, called Arcturus. This paper is a report of work in progress giving our preliminary philosophy and expressing preliminary thoughts on an initial Arcturus design.Arcturus is an advanced, highly-integrated programming environment intended for use in the late 1980s. We assume that programmers will each be equipped with large flat-screen displays driven by powerful desk-top computers linked into local networks by high band-width channels, and that shared central resources such as archival databases and multifont printing systems will be available.Arcturus is aimed at "programming in the large", that is, programming by many people, on large programs, with maintenance lifetimes of many years. In such a user setting, problems of management, documentation, training, testing, version control, diagnosis, and debugging must be solved effectively by people who, for the most part, are not authors or designers of the original system.Some preliminary design concepts that Arcturus supports are as follows:(1) Arcturus supports a "rapid prototyping" language -- a very high level, strongly extensible language useful for rapid construction of working prototypes of systems (emphasizing cheap, rapid construction at the expense of running efficiency and polish).(2) Arcturus supports refinement of these prototype programs, or protoprograms, for short, into programs written in program design languages (or PDLs) , which express designs. PDL programs are ultimately refined into concrete, detailed, optimized programs expressed in an implementation language.(3) Arcturus supports a computer-based form of program documentation in which program forms at various levels of abstraction can have attribute/value pairs attached to any of their granules (granules being well-formed program units of any size such as constants, variables, operators, expressions, statements, blocks, and modules) and in which the attributes may be selectively viewed and queried to suit the needs of different audiences.(4) The notion of attribute/value attachment to granules of program forms also supplies the principal mechanism for promoting a high degree of environment integration. By attaching to program granules such attributes as clocks, counters, units of programmer and system resources spent, version descriptions, access controls, descriptions of tests passed, task schedule data, computer sizing estimates, and so on, smooth integration between the activities of designers, managers, testers, maintainers, programmers, and documenters can be achieved, and environment tools can cooperate with each other conveniently.(5) Arcturus supports an advanced programmer's workstation, an interactive programmer's notebook, and extensive software management support tools.In the framework of the Arcturus effort, we have attempted to rethink afresh issues of epistemology related to the programming process that impact documentation, fault diagnosis, maintenance, training, and software upgrade, so that the design of Arcturus will reflect the relationships between the different kinds of expertise that are required in the programming process. We are also attempting to formulate theories of documentation, debugging, and maintenance to guide the development of computer-based support capabilities that assist in the performance of these activities.In this context, this paper contains preliminary, tentative expositions of background philosophy and rationale that guide our present thinking about Arcturus

Collaborative engineering-design support system

Designing engineering objects requires many engineers' knowledge from different domains. There needs to be cooperative work among engineering designers to complete a design. Revisions of a design are time consuming, especially if designers work at a distance and with different design description formats. In order to reduce the design cycle, there needs to be a sharable design describing the engineering community, which can be electronically transportable. Design is a process of integrating that is not easy to define definitively. This paper presents Design Script which is a generic engineering design knowledge representation scheme that can be applied in any engineering domain. The Design Script is developed through encapsulation of common design activities and basic design components based on problem decomposition. It is implemented using CLIPS with a Windows NT graphical user interface. The physical relationships between engineering objects and their subparts can be constructed in a hierarchical manner. The same design process is repeatedly applied at each given level of hierarchy and recursively into lower levels of the hierarchy. Each class of the structure can be represented using the Design Script

Facilitating teacher participation in intelligent computer tutor design : tools and design methods.

This work addresses the widening gap between research in intelligent tutoring systems (ITSs) and practical use of this technology by the educational community. In order to ensure that ITSs are effective, teachers must be involved in their design and evaluation. We have followed a user participatory design process to build a set of ITS knowledge acquisition tools that facilitate rapid prototyping and testing of curriculum, and are tailored for usability by teachers. The system (called KAFITS) also serves as a test-bed for experimentation with multiple tutoring strategies. The design includes novel methodologies for tutoring strategy representation (Parameterized Action Networks) and overlay student modeling (a layered student model), and incorporates considerations from instructional design theory. It also allows for considerable student control over the content and style of the information presented. Highly interactive graphics-based tools were built to facilitate design, inspection, and modification of curriculum and tutoring strategies, and to monitor the progress of the tutoring session. Evaluation of the system includes a sixteen-month case study of three educators (one being the domain expert) using the system to build a tutor for statics (forty topics representing about four hours of on-line instruction), testing the tutor on a dozen students, and using test results to iteratively improve the tutor. Detailed throughput analysis indicates that the amount of effort to build the statics tutor was, surprisingly, comparable to similar figures for building (non-intelligent) conventional computer aided instructional systems. Few ITS projects focus on educator participation and this work is the first to empirically study knowledge acquisition for ITSs. Results of the study also include: a recommended design process for building ITSs with educator participation; guidelines for training educators; recommendations for conducting knowledge acquisition sessions; and design tradeoffs for knowledge representation architectures and knowledge acquisition interfaces