Writing requirements is no easy task. Common problems include ambiguity in statements, specifications at the wrong level of abstraction, statements with inconsistent references to types, conflicting requirements, and incomplete requirements. These pitfalls lead to errors being introduced early in the design process. The longer the gap between error introduction and error discovery, the higher the cost associated with the error. To address the growing cost of system development, we introduce a tool called ASSERT" (Analysis of Semantic Specifications and Efficient generation of Requirements-based Tests) for capturing requirements, backed by a formal requirements analysis engine. ASSERT" also automatically generates a complete set of requirements-based test cases. Capturing requirements in an unambiguous way and then formally analyzing them with an automated theorem prover eliminates errors as soon as requirements are written. It also addresses the historical problem that analysis engines are hard to use for someone without formal methods expertise and analysis results are often difficult for the end-user to understand and make actionable. ASSERT"'s major contribution is to bring powerful requirements capture and analysis capability to the domain of the end-user. We provide explainable and automated formal analysis, something we found important for a tool's adoptability in industry.

Capturing high-level requirements in a human readable but formal representation suitable for analysis is an important goal for GE. To that end we have augmented an existing controlled-English modeling language with a new controlled-English requirements capture language to create the Requirements Capture frontend of the ASSERT(TM) tool suite. Requirements captured in ASSERT can be analyzed for a number of possible shortcomings, both individually and collectively. Once a set of requirements has reached a satisfactory level of completeness, consistency, etc., it can then be further used to generate test cases and test procedures. This paper will focus on the requirements capture and analysis functions of ASSERT and will illustrate its capabilities with a sample problem previously used as a challenge problem for requirements specification.

Capturing domain knowledge can be a time-consuming process that typically requires the collaboration of a Subject Matter Expert and a modeling expert to encode the knowledge. In a number of domains and applications, this situation is further exacerbated by the fact that the Subject Matter Expert may find it difficult to articulate the domain knowledge as a procedure or rules, but instead may find it easier to classify instance data. To facilitate this type of knowledge elicitation from Subject Matter Experts, we have developed a system that automatically generates formal and executable rules from provided labeled instance data. We do this by leveraging the techniques of Inductive Logic Programming (ILP) to generate Horn clause based rules to separate out positive and negative instance data. We illustrate our approach on a Design For Manufacturability (DFM) platform where the goal is to design products that are easy to manufacture by providing early manufacturability feedback. Specifically we show how our approach can be used to generate feature recognition rules from positive and negative instance data supplied by Subject Matter Experts. Our platform is interactive, provides visual feedback and is iterative. The feature identification rules generated can be inspected, manually refined and vetted.

A stepwise method of deriving the high-performance implementation of a set of operations is proposed. This method is based on the ability to organize the data into a multilevel data structure to provide an efficient implementation of all the operations. Typically, for such data organization the performance may deteriorate over a period of time and that can be corrected by reorganizing the data. This data reorganization is done by the introduction of maintenance processes. For a particular example, the multilevel data organization and the different models of maintenance processes possible are considered. The various models of maintenance process provide varying amounts of concurrency by varying the degree of atomicity in different operations. Performance behavior for the different models is derived and a correctness proof for the developed implementation is outlined.>

A recent trend in program methodologies is to derive efficient parallel programs from sequential programs. This study explores the question of transforming a sequential algorithm into an efficient parallel algorithm by considering the problem of balancing binary search trees. The derivation of the parallel algorithm makes use of stepwise refinement. The authors first derive a new iterative balancing algorithm that exploits the similarity of point restructuring required at all the nodes at the same level. From this they derive a parallel algorithm that has time complexity O(1) on anN-processor configuration. This achieves the theoretical limit of speedup possible in a multiprocessor configuration.

Today's technological and economic profile make it desirable to attempt distributed solutions for a majority of computing tasks. In this paper we describe a scheme by which a sequential program can be transformed into a weakly equivalent distributed program. This transformation can, in principle, be automated and is applicable to any program written in a sequential guarded command language. The sequential program to be transformed must be accompanied by a disjoint yet complete partitioning of its variables into n sets; thereafter the program can be transformed into a system of n communicating processes written in CSP.

Algebraic specification is now an established way of formally defining abstract data types. For its practical use, however, a segment of program which conforms with the specification has to be generated. Such program segments can be manually produced and must then be verified. Code generation can also be automated, as achieved by the "direct implementation" in [8] where any data type is treated as if its functions produce, manipulate, and access tree structures. We extend these results by formalizing the choice of the appropriate data type (e.g., a tree structure) required to "implement" any given data type. This allows us to consider the formal implementation of a data type in terms of a concrete model.

Abstract Text composition software is mainly used by compositors, who are usually not programmers, and who do not necessarily know much about the underlying technicalities of computer usage. It is important, therefore, that the text composition system be such that a compositor would have a minimum amount of learning to do. Factors such as flexibility of style specification and economical proof generation are important from a user's point of view. On the other hand, multilingual text input, output device independence and system portability are points of concern for the system designer. In this paper, a specific text composition software system designed on the basis of such considerations is briefly described. The way in which the above‐mentioned factors affect the design of the system is discussed in some detail.