Christopher Landauer

Correctness principles for rule-based expert systems

Abstract This paper defines a set of acceptability principles for a rulebase. The principles go beyond mathematical correctness concerns to distribution and simplicity conditions that can signal the existence of errors or awkwardness in the rules. The principles are Consistency, Completeness, Irredundancy, Connectivity , and Distribution . The intent of these principles is to assist the rulebase designer in constructing a rulebase and validating its behavior. The five principles are implemented by mathematical and computational criteria that specify algorithms for analyzing rulebases. The Consistency criteria address the logical consistency of the rules, and can rightly be considered “correctness” criteria. The Completeness and Irredundancy criteria preclude oversights in specifications and redundancy in the rules, and are more like “reasonability” criteria for the terms in the rules. The Connectivity criteria concern the inference system defined by the rules, and are like completeness and irredundancy criteria for the inference system. Finally, the Distribution criteria are “esthetic” criteria for the simplicity of the rules and the distinctions they cause, as well as the distribution of the rules and the values implied by them. These procedures do not solve the (hard) problem of choosing a representation for the important features of the system being modeled, and turning the characteristics of the features into rules. They only allow a set of rules to be checked for the various criteria, so that many commonly occurring specification errors can be caught quickly. This paper discusses the formation of rulebases from a set of rules, not the formulation of rules from a system under study.

Generic programming, partial evaluation, and a new programming paradigm

We describe in this paper a new approach to Generic Programming that combines our integration results with Partial Evaluation methods for adaptation. Our approach supports Partial Evaluation by providing much more information than is usually available, including explicit meta-knowledge about the program fragments and their intended execution environments. We make some ambitious claims here, so we provide some detail about our methods, to justify our interest and expectations. We are not claiming to have solved the problem; only that we think our methods circumvent some of the know difficulties that were previously identified or encountered in approaches to Generic Programming.

Self-modeling systems

This paper is about systems with complete models of themselves (down to some very low level of detail). We explain how to build such a system (using careful system engineering, and our Wrapping approach to flexible integration infrastructures for Constructed Complex Systems), and why we want to do so (it is at least interesting, and we believe it is essential for effective autonomy). The long-term goal is the use of these models to understand modeling processes, so that computing systems can be built that can do their own modeling and construct their own abstractions, which we believe is important for computational intelligence.

Integration Systems and Interaction Spaces

Integration systems are abstract methods of combining theories, computational paradigms, algorithms, and other rule-driven symbolic processing systems. This paper discusses our hopes and our progress in creating a principled approach to a theory of integration for large systems. First, we discuss two types of integration systems, distinguished by the flexibility of the integration process and the types of infrastructure that they retain. In the next section of the paper, we present our approach to creating an integration infrastructure through the processing of explicit meta-knowledge. In the following section, we introduce some work on combining wrappings with text-based Virtual Reality environments to form a new kind of integration infrastructure, and in the last section, we discuss the requirements for formalisms that have emerged from working in these testbeds. This research was supported in part by the Aerospace Corporation’s Sponsored Research Program, by the Federal Highway Administration’s Office of Advanced Research, and by the Advanced Research Projects Agency’s Software and Intelligent Systems Technology Office.

Wrapping Mathematical Tools

This paper discusses the problem of making mathematical tools more usefully available to a heterogeneous modelling environment. The goal is to make explicit both the knowledge embodied in existing programs and their styles of use. The approach is to “wrap” each existing program with an expert system that contains a description of the knowledge of the program, so that other components of the environment can interact usefully with the wrapped program. The wrapping is a kind of smart interface filter that allows a computational program to be a component of the environment. It contains a large amount of self-description, including what the component does; reasons for using this component instead of others; constraints on acceptable problem specifications; rules for default values; what this component needs from its environment in the way of problem statements, auxiliary data, and computation; and other knowledge about how to use the component. This paper defines wrapping and discusses its importance, and presents some of the issues that arise when existing computational programs are wrapped.

Wrappings for software development

Constructed complex systems are heterogeneous software and hardware systems that have to function in complex environments. Building and managing such a system requires explicit infrastructure that includes models of the system, its architecture, and its environment. We describe wrapping, our knowledge-based integration infrastructure, and show by example how the meta-knowledge that wrappings contain, and the expressive uniformities that result from stepping up to a meta-level, lead to much cleaner descriptions of many software processes. We describe our problem posing interpretation of programming languages, and the corresponding wrapping expression notation wrex, and show its use both for programming the internal details of a system and for describing a system lifecycle process. We apply our methods to two examples: migration of disparate database systems into a common standard, and the process of software disintegration, which identifies models of components of software and should be part of any software or system re-engineering process.

Problem posing interpretation of programming languages

In this paper, we describe a programming paradigm that changes the focus of programming from solution methods for certain application problems to the specification of the problems themselves, leaving the mapping from the problem specification to the computational resources that will provide or coordinate the solution to one or more separate (and possibly external) information files, knowledge bases, or other processes. The Problem Posing Interpretation is a declarative programming paradigm that uses Knowledge-Based Polymorphism to unify the interpretation of all programming languages. We describe examples from all major programming paradigms, to justify this claim.

Theoretical Biology: Organisms and Mechanisms

The Theoretical Biology Program initiated by Robert Rosen is intended to identify the key theoretical characteristics of organisms, especially those that distinguish organisms from mechanisms, by looking for the proper abstractions and defining the appropriate relationships. There are strong claims about the distinctions in Rosen’s book “Life Itself”, along with some purported proofs of these assertions. Unfortunately, the Mathematics is incorrect, and the assertions remain unproven (and some of them are simply false). In this paper, we present the ideas of Rosen’s approach, demonstrate that his Mathematical formulations and proofs are wrong, and then show how they might be made more successful.

Designing testable, heterogeneous software environments

Abstract Over the last 8 years, our group has focused on developing techniques for designing, testing, and evaluating several new computer technologies, including knowledge-based systems (KBSs). However, even as we speak, the technologies that we need to contend with are changing; rarely to these new technologies come alone. Instead, we are in an era where the problems we are working on demand large software environments with tool sets and libraries composed of often very different types of components. We see fuzzy controllers combined with knowledge bases and neural nets, and all of these combined with standard graphic programs, user interfaces, computer algorithms, spreadsheet programs, editors, data base management systems, etc. In this article we introduce a methodology for constructing large heterogeneous software environments in such a way as to make them “testable” and maintainable. The article is divided into two parts. First, we introduce our “wrapping” approach to engineering software environments. In wrapping, we create machine-processable descriptions for all the software resources in a system. These descriptions include not only the usual protocol and input requirements for applying a software resource, but also metaknowledge about the appropriate content for applying a resource and adapting a resource to different problems. In the second part of the article, we briefly review the verification and validation methods we have developed for testing KBSs, discuss how these methods can be directly applied to the data bases that hold the “wrappings,” and use the verification and validation methods to analyze a simple example.

Playing in the mud: Virtual worlds are real places

This paper is about how developers will know whether intelligent virtual environments (IVEs) are appropriate for the tasks set to them. There are several important research questions that need to be answered before they can even begin to build IVEs for some of the more promising applications, such as entertainment, education, collaboration on research and development, military, and other training. The main technical point is that every aspect of any IVE involves model, and the modeling needs to be addressed very directly and explicitly. This paper is more for the developers of such systems and the potential customers, than for the users. More is written about what is important to consider as one contemplates, for example, a difficult collaborative task, than about what it will be like to live in these IVEs. The authors believe that IVEs must be expanded to become virtual worlds (VWs), and that the modeling sophistication required for any of the serious applications described above is much more than is currently available in the VWs seen, even the ones with good graphics. Finally, the connection between Virtual Reality and CyberSpace is made, and the authors explain their expectations will be explained for the future of CyberSpace.