Making sense of the abstraction hierarchy in the power plant domain

The paper discusses the abstraction hierarchy proposed by Rasmussen [(1986) Information processing and human-machine interaction, North-Holland] for design of human-machine interfaces for supervisory control. The purpose of the abstraction hierarchy is to represent a work domain by multiple levels of means-end and part-whole abstractions. It is argued in the paper that the abstraction hierarchy suffers from both methodological and conceptual problems. A cluster of selected problems are analyzed and illustrated by concrete examples from the power plant domain. It is concluded that the semantics of the means-end levels and their relations are vaguely defined and therefore should be improved by making more precise distinctions. Furthermore, the commitment to a fixed number of levels of means-end abstractions should be abandoned and more attention given to the problem of level identification in the model-building process. It is also pointed out that attempts to clarify the semantics of the abstraction hierarchy will invariably reduce the range of work domains where it can be applied.     

Planning collision-free trajectories in time-varying environments: a two-level hierarchy

We propose a two-level hierarchy for planning collision-free trajectories in time varying environments. Global geometric algorithms for trajectory planning are used in conjunction with a local avoidance strategy. Simulations have been developed for a mobile robot in the plane among stationary and moving obstacles. Essentially, the robot has a global geometric planner that provides a coarse global trajectory (the path and velocity along it), which may be locally modified by the low-level local avoidance module if local sensors detect any obstacles in the vicinity of the robot. This hierarchy makes effective use of the complementary aspects of the global trajectory planning approaches and the local obstacle avoidance approaches.     

Providing ranked cooperative query answers using the metricized knowledge abstraction hierarchy

Cooperative query answering supports query relaxation and provides approximate answers as well as exact answers. To facilitate the query relaxation, a knowledge representation framework has been widely adopted, which accommodates semantic relationships or distance metrics to represent similarities among data values. In this paper, we propose a metricized knowledge abstraction hierarchy (MKAH) that supports multi-level data abstraction hierarchy and distance metric among data values. We show that the abstraction hierarchy is useful in representing the semantic relationship, and the abstraction hierarchy can provide data values with different scope according to their abstraction levels. The distance metric expresses the semantic similarity among data values with quantitative measure, and thus it enables query results to be ranked. To verify the practicality and effectiveness of the MKAH, we have implemented a prototype system in the area of career job search. Through various experiments, we show that the MKAH provides rich semantic representation and high quality distance measure. Furthermore, the experiments confirm that the domain adopting the MKAH can be compatible with other numeric domains, and that is advantageous in building up large scaled systems.     

Cyberworlds: architecture and modeling by an incrementally modular abstraction hierarchy

An incrementally modular abstraction hierarchy, which specifies, models and visualizes the architecture of cyberworlds from general to specific, is presented. The hierarchy, consisting of a homotopy level with fiber bundles, a set theoretical space level, a topological space level, an adjunction space level, a cellular space level, and presentation and view-levels, is described theoretically with examples of online book shopping such as e-commerce, seat assembling as such e-manufacturing, and accounting such as e-economy. Sharing invariants defined at each level contributes to robust architecture and modeling for designing, analyzing, implementing and visualizing cyberworlds, which results in a fault-free reduction of time and cost.     

Planning with abstraction based on partial predicate mappings

Planning with abstraction is an act of finding an abstract plan that can be instantiated into a concrete plan for a given planning problem. It is very important for an abstract planning system to satisfy a property, calledDownward-Solution Property (DSP), that any abstract plan can always be instantiated into a concrete plan. J. D. Tenenberg has proposed a framework for constructing a planning system satisfying DSP. The system is constructed by abstracting operators under a givenpredicate mapping f to obtain abstract operators. Intuitively speaking, the predicate mapping corresponds to an inheritance hierarchy of concepts with which the planning is concerned. However, the condition for abstracting operators is so strong that there exist many cases whereonly a few abstract operators are obtained. Consequently, the system often generates only a very small abstract search space, and therefore fails to find a plan for a given problem at concrete level. The aim of this paper is to provide a new revised framework according to which we can construct a more flexible abstract planning system still preserving DSP. For this purpose, we introduce a notion ofpartial predicate mapping. Partial predicate mappings are computed from concrete operators andf. Intuitively, computing them corresponds to refiningf into mappings under which it is possible to obtain more number of abstract operators. Furthermore, some experimental results show that using our abstraction based on partial predicaate mappings is useful to improve planning efficiency.     

Accounting for memes in sociotechnical systems: extending the abstraction hierarchy to consider cognitive objects

Work domain analysis (WDA) is used to model the functional structure of sociotechnical systems (STS) through the abstraction hierarchy (AH). By identifying objects, processes, functions and measures that support system purposes, WDA reveals constraints within the system. Traditionally, the AH describes system elements at the lowest level of abstraction as physical objects. Multiple analyses of complex systems reveal that many include objects that exist only at a conceptual level. This paper argues that, by extending the AH to include cognitive objects, the analytical power of WDA is extended, and novel areas of application are enabled. Three case studies are used to demonstrate the role that cognitive objects play within STS. It is concluded that cognitive objects are a valid construct that offer a significant enhancement of WDA and enable its application to some of the world’s most pressing problems. Implications for future applications of WDA and the AH are discussed.

Practitioner summary: Some sociotechnical systems include memes as part of their functional structure. Three case studies were used to evaluate the utility of introducing cognitive objects alongside physical ones in work domain analysis, the first phase of cognitive work analysis. Including cognitive objects increases the scope and accuracy of work domain analysis.     

Designing and modeling cyberworlds using the incrementally modular abstraction hierarchy based on homotopy theory

For designing and modeling complicated and sophisticated systems such as cyberworlds, their mathematical foundation is critical. To realize it, two important properties called the homotopy lifting property (HLP) and homotopy extension property (HEP) are applied for designing and modeling a system in a bottom-up way and a top-down way, respectively. In this paper, an enterprise system and a real-time embedded system are considered as important socially emerging cases of cyberworlds, where the π-calculus processes for describing these behaviors formally, a Petri net for explaining process interactions, and XMOS XC programs are modeled and designed by our approach. The spaces in both properties are specified by the incrementally modular abstraction hierarchy by climbing down the abstraction hierarchy from the most abstract homotopy level to the most specific view level, while keeping invariants such as homotopy equivalence and topological equivalence.     

An approximation algorithm for box abstraction of transition systems on real state spaces

Predicate abstraction is a powerful technique for extracting finite-state models from infinite-state systems such as computer software, and is applied to verification of safety properties. Predicate abstraction is also applied to verification of dynamical systems on real state spaces such as hybrid dynamical systems. In this paper, we propose a fast algorithm for computing entire abstract state spaces of transition systems on real state spaces. The method is based on the box abstraction of state spaces, and requires a relatively smaller number of reachability checks and Boolean operations. We also propose a fast method for computing the set of boxes that intersect a given convex polyhedron. This computation is a part of the proposed state-space generation algorithm. Effectiveness of the algorithm is evaluated by the computation time and by the difference of the approximated state space from the exact state space.     

Predicate abstraction in a program logic calculus

Predicate abstraction is a form of abstract interpretation where the abstract domain is constructed from a finite set of predicates over the variables of the program. This paper explores a way to integrate predicate abstraction into a calculus for deductive program verification based on symbolic execution, where it allows us to infer loop invariants automatically that would otherwise have to be given interactively. The approach has been implemented as a part of the KeY verification system.     

Implementing data abstraction features in a stack-based language

This paper describes SIMPL-D, a stack-based language with data abstraction features, and some of the details of its implementation. The language allows users to define new types that are parameterized by size and to perform system-defined operations (e.g. assignment) on objects with user-defined types. The use of object-describing templates in the implementation of storage allocation, assignment and returning values from functions is discussed. Finally, the conflicts between automatic initialization and separate compilation are explained.     

Identifying problems and generating recommendations for enhancing complex systems: applying the abstraction hierarchy framework as an analytical tool

OBJECTIVE: This study adopts J. Rasmussen's (1985) abstraction hierarchy (AH) framework as an analytical tool to identify problems and pinpoint opportunities to enhance complex systems. BACKGROUND: The process of identifying problems and generating recommendations for complex systems using conventional methods is usually conducted based on incompletely defined work requirements. As the complexity of systems rises, the sheer mass of data generated from these methods becomes unwieldy to manage in a coherent, systematic form for analysis. There is little known work on adopting a broader perspective to fill these gaps. METHOD: AH was used to analyze an aircraft-automation system in order to further identify breakdowns in pilot-automation interactions. Four steps follow: developing an AH model for the system, mapping the data generated by various methods onto the AH, identifying problems based on the mapped data, and presenting recommendations. RESULTS: The breakdowns lay primarily with automation operations that were more goal directed. Identified root causes include incomplete knowledge content and ineffective knowledge structure in pilots' mental models, lack of effective higher-order functional domain information displayed in the interface, and lack of sufficient automation procedures for pilots to effectively cope with unfamiliar situations. CONCLUSION: The AH is a valuable analytical tool to systematically identify problems and suggest opportunities for enhancing complex systems. It helps further examine the automation awareness problems and identify improvement areas from a work domain perspective. APPLICATION: Applications include the identification of problems and generation of recommendations for complex systems as well as specific recommendations regarding pilot training, flight deck interfaces, and automation procedures.     

Syntactic abstraction in scheme

Naive program transformations can have surprising effects due to the interaction between introduced identifier references and previously existing identifier bindings, or between introduced bindings and previously existing references. These interactions can result in inadvertent binding, or capturing, of identifiers. A further complication is that transformed programs may have little resemblance to original programs, making correlation of source and object code difficult. This article describes an efficient macro system that prevents inadvertent capturing while maintaining the correlation between source and object code. The macro system allows the programmer to define program transformations using an unrestricted, general-purpose language. Previous approaches to the capturing problem have been inadequate, overly restrictive, or inefficient, and the problem of source-object correlation has been largely unaddressed. The macro system is based on a new algorithm for implementing syntactic transformations and a new representation for syntactic expressions.This material is based on work supported by the National Science Foundation under grant number CCR-8803432.Robert Hieb died in an automobile accident in April 1992.     

Defining interfaces at a high level of abstraction

One of the newest user-interface management systems, the User-Interface Development Environment, is described by its creators. UIDE is built around a knowledge-based representation of the conceptual design of a user interface. UIDE supports design at a high-level specification of the interface from information provided by the designer. By using the same knowledge base, the interface developer can generate a new interface design with the same functionality as the original design. This lets users try many functionally equivalent interfaces for the same application     

Environment as a first class abstraction in multiagent systems

The current practice in multiagent systems typically associates the environment with resources that are external to agents and their communication infrastructure. Advanced uses of the environment include infrastructures for indirect coordination, such as digital pheromones, or support for governed interaction in electronic institutions. Yet, in general, the notion of environment is not well defined. Functionalities of the environment are often dealt with implicitly or in an ad hoc manner. This is not only poor engineering practice, it also hinders engineers to exploit the full potential of the environment in multiagent systems. In this paper, we put forward the environment as an explicit part of multiagent systems.We give a definition stating that the environment in a multiagent system is a first-class abstraction with dual roles: (1) the environment provides the surrounding conditions for agents to exist, which implies that the environment is an essential part of every multiagent system, and (2) the environment provides an exploitable design abstraction for building multiagent system applications. We discuss the responsibilities of such an environment in multiagent systems and we present a reference model for the environment that can serve as a basis for environment engineering. To illustrate the power of the environment as a design abstraction, we show how the environment is successfully exploited in a real world application. Considering the environment as a first-class abstraction in multiagent systems opens up new horizons for research and development in multiagent systems.     

MeterPU: a generic measurement abstraction API

We present MeterPU, an easy-to-use, generic and low-overhead abstraction API for taking measurements of various metrics (time, energy) on different hardware components (e.g., CPU, DRAM, GPU) in a heterogeneous computer system, using pluggable platform-specific measurement implementations behind a common interface in C++. We show that with MeterPU, not only legacy (time) optimization frameworks, such as autotuned skeleton back-end selection, can be easily retargeted for energy optimization, but also switching between measurement metrics or techniques for arbitrary code sections now becomes trivial. We apply MeterPU to implement the first energy-tunable skeleton programming framework, based on the SkePU skeleton programming library.     

Sequential debugging at a high level of abstraction

Efforts to build a better mousetrap for bugs in sequential programs are described. The resulting debugger, called Dalek, is intended to remedy limitations in conventional execution harnesses. Beyond the simple `stop and look' features offered by typical breakpoint debuggers, Dalek offers a rich control and query language. Dalek's linguistic capabilities for treating sequences of program events offer an improvement over scratch paper as a compensatory technology for human memory limitations. Example applications are given. The very interactive, dynamic style of debugging encouraged by Dalek is discussed     

Unsupervised shape learning in a neuromorphic hierarchy

We present a neural-based learning system for object recognition in still gray-scale images. The system comprises several hierarchical levels of increasing complexity modeling the feed-forward path of the ventral stream in the visual cortex. It learns typical shape patterns of objects as these appear in images from experience alone without any prior labeling. Information about the exact origin of parts of the stimulus is systematically discarded, while the shape-related object identity information is preserved, resulting in strong compression of the original image data. To demonstrate it’s capabilities, we train the system on publicly available image databases and use it’s final output in classification tasks. The text was submitted by the authors in English. Daniel Oberhoff received a diploma in physics in 2004 from ETH Zurich, where he spent over a year in the Physics of New Materials group of the solid state physics department working on the characterization and simulation of organic electronic devices. In the fall of 2005, he began work on his PhD thesis on biologically inspired machine learning for computer vision with Fraunhofer Gesellschaft at Schloss Birlinghoven in Sankt-Augustin, Germany. Marina Kolesnik received her masters degree in physics and engineering in 1984 from Moscow Institute of Physics and Technology and a PhD in computer science in 1993 from the Russian Academy of Sciences. From 1984 to 1995, she worked as a research scientist at the Space Research Institute in Moscow, Russia. In 1995–1996, she was a visiting researcher as a Lise-Meitner fellow at JOANNEUM Research in Graz, Austria. She obtained a Max-Planck fellowship in 1996. Since 1997, she has been a research scientist at the GMD Research Center and, since 2002, at Fraunhofer Gesellschaft in Sankt-Augustin, Germany. Her research interests include computer vision, vision-based operations, and visual perception and modeling of visual pathways for computer vision applications.     

Preserving abstraction in concurrent programming

Recent programming languages have attempted to provide support for concurrency and for modular programming based on abstract interfaces. Building on experience of adding monitors to CLU, a language oriented towards data abstraction, it is explained how these two goals conflict. In particular, the clash between conventional views on interface abstraction and the programming style required for avoiding monitor deadlock is discussed. It is argued that the best compromise between these goals is a combination of a fine-grain locking mechanism together with a method for explicitly defining concurrency properties for selected interfaces