Logic Programming as Constructivism

The features of logic programming that seem unconventional from the viewpoint of classical logic can be explained in terms of constructivistic logic. We motivate and propose a constructivistic proof theory of non-Horn logic programming. Then, we apply this formalization for establishing results of practical interest. First, we show that 'stratification can be motivated in a simple and intuitive way. Relying on similar motivations, we introduce the larger classes of 'loosely stratified' and 'constructively consistent' programs. Second, we give a formal basis for introducing quantifiers into queries and logic programs by defining 'constructively domain independent* formulas. Third, we extend the Generalized Magic Sets procedure to loosely stratified and constructively consistent programs, by relying on a 'conditional fixpoini procedure

Optimizing Feature Interaction Detection

© 2017, Springer International Publishing AG. The feature interaction problem has been recognized as a general problem of software engineering. The problem appears when a combination of features interacts generating a conflict, exhibiting a behaviour that is unexpected for the features considered in isolation, possibly resulting in some critical safety violation. Verification of absence of critical feature interactions has been the subject of several studies. In this paper, we focus on functional interactions and we address the problem of the 3-way feature interactions, i.e. interactions that occur only when three features are all included in the system, but not when only two of them are. In this setting, we define a widely applicable definition framework, within which we show that a 3 (or greater)-way interaction is always caused by a 2-way interaction, i.e. that pairwise sampling is complete, hence reducing to quadratic the complexity of automatic detection of incorrect interaction

Template-based geometric transformations of a functionally enriched DMU into FE assembly models

International audiencePre-processing of CAD models derived from Digital Mock-Ups (DMUs) into finite element (FE) models is usually completed after many tedious tasks of model preparation and shape transformations. It is highly valuable for simulation engineers to automate time-consuming sequences of assembly preparation processes. Here, it is proposed to use an enriched DMU with geometric interfaces between components (contacts and interferences) and functional properties. Then, the key concept of template-based transformation can connect to assembly functions to locate consistent sets of components in the DMU. Subsequently, sets of shape transformations feed the template content to adapt components to FE requirements. To precisely monitor the friction areas and the mesh around bolts, the template creates sub-domains into their tightened components and preserves the consistency of geometric interfaces for the mesh generation purposes. From a user-selected assembly function, the method is able to robustly identify, locate and transform groups of components while preserving the consistency of the assembly needed for FE models. To enlarge the scope of the template in the assembly function taxonomy, it is shown how the concept of dependent function enforces the geometric and functional consistency of the transformed assembly. To demonstrate the proposed approach, a business oriented prototype processes bolted junctions of aeronautical structures

ASSEMBLY DIFFERENTIATION IN CAD SYSTEMS

This work presents a data model for differentiating and sharing assembly design (AsD) information during collaborative design. Joints between parts are an important aspect of assembly models that are often ambiguous when sharing of models takes place. Although various joints may have similar geometries and topologies, their joining methods and process parameters may vary significantly. It is possible to attach notes and annotations to geometric entities within CAD environments in order to distinguish joints; however, such textual information does not readily prepare models for sharing among collaborators or downstream processes such as simulation and analysis. At present, textual information must be examined and interpreted by the human designer and cannot be interpreted or utilized by the computer; thus, making the querying of information potentially cumbersome and time consuming.This work presents an AsD ontology that explicitly represents assembly constraints, including joining constraints, and infers any remaining implicit ones. By relating concepts through ontology technology rather than just defining an arbitrary data structure, assembly and joining concepts can be captured in their entirety or extended as necessary. By using the knowledge captured by the ontology, similar-looking joints can be differentiated and the collaboration and downstream product development processes further automated, as the semantics attached to the assembly model prepares it for use within the Semantic Web

Qualitative behavioral reasoning from components' interfaces to components' functions for DMU adaption to FE analyses

International audienceA digital mock-up (DMU), with its B-Rep model of product components, is a standard industrial representation that lacks geometric information about interfaces between components. Component shapes reflect common engineering practices that influence component interfaces with interferences and not only contacts. The proposed approach builds upon relationships between function, behavior, and shape to derive functional information from the geometry of component interfaces. Among these concepts, the concept of behavior is more difficult to set up and connect to the geometry of interfaces and functions. Indeed, states and design rules are introduced to express the behavior of components through a qualitative reasoning process. This reasoning process, in turn, takes advantage of domain knowledge rules and facts, checking the validity of certain hypotheses that must hold true all along a specific state of the product's lifecycle, such as operational, stand-by or relaxed states. Eliminating configurations that contradict one or more of those hypotheses in their corresponding reference state reduces ambiguity, subsequently producing functional information in a bottom-up manner. This bottom-up process starts with the generation of a conventional interfaces graph (CIG) with components as nodes, and conventional interfaces (CIs) as arcs. A CI is initially defined by a geometric interaction that can be a contact or an interference between two components. CIs are then populated with functional interpretations (FIs) according to their geometric properties, producing potentially many combinations. A first step of the reasoning process, the validation against reference states, reduces the number of FIs per CI. Domain knowledge rules are then applied again to group semantics of component interfaces into one functional designation per component to connect together geometric entities of its boundary with its function

Knowledge-Based Design Patterns for Detailed Ship Structural Design

For detailed ship structural design standardization is a means to ensure a consistent build quality and to reduce design costs. With standards expressed electronically and using a knowledge-based approach, a rule-based system for the automatic design of standardized structural details is presented. For selected problems the corresponding rule formulations are developed; more advanced design tasks are solved by a bottom-up approach. As a result, the automatic, standards compliant design and validation is achieved, hence ensuring consistency as well as reducing the probability of design errors

A Feature-Oriented Modelling Language and a Feature-Interaction Taxonomy for Product-Line Requirements

Many organizations specialize in the development of families of software systems, called software product lines (SPLs), for one or more domains (e.g., automotive, telephony, health care). SPLs are commonly developed as a shared set of assets representing the common and variable aspects of an SPL, and individual products are constructed by assembling the right combinations of assets. The feature-oriented software development (FOSD) paradigm advocates the use of system features as the primary unit of commonality and variability among the products of an SPL. A feature represents a coherent and identifiable bundle of system functionality, such as call waiting in telephony and cruise control in an automobile. Furthermore, FOSD aims at feature-oriented artifacts (FOAs); that is, software-development artifacts that explicate features, so that a clear mapping is established between a feature and its representation in different artifacts. The thesis first identifies the problem of developing a suitable language for expressing feature-oriented models of the functional requirements of an SPL, and then presents the feature-oriented requirements modelling language (FORML) as a solution to this problem. FORML's notation is based on standard software-engineering notations (e.g., UML class and state-machine models, feature models) to ease adoption by practitioners, and has a precise syntax and semantics to enable analysis. The novelty of FORML is in adding feature-orientation to state-of-the-art requirements modelling approaches (e.g., KAOS), and in the systematic treatment of modelling evolutions of an SPL via enhancements to existing features. An existing feature can be enhanced by extending or modifying its requirements. Enhancements that modify a feature's requirements are called intended feature interactions. For example, the call waiting feature in telephony intentionally overrides the basic call service feature's treatment of incoming calls when the subscriber is already involved in a call. FORML prescribes different constructs for specifying different types of enhancements in state-machine models of requirements. Furthermore, unlike some prominent approaches (e.g., AHEAD, DFC), FORML's constructs for modelling intended feature interactions do not depend on the order in which features are composed; this can lead to savings in analysis costs, since only one rather than (possibly) multiple composition orders need to be analyzed. A well-known challenge in FOSD is managing feature interactions, which, informally defined, are ways in which different features can influence one another in defining the overall properties and behaviours of their combination. Some feature interactions are intended, as described above, while other feature interactions are unintended: for example, the cruise control and anti-lock braking system features of an automobile may have incompatible affects on the automobile's acceleration, which would make their combination inconsistent. Unintended feature interactions should be detected and resolved. To detect unintended interactions in models of feature behaviour, we must first define a taxonomy of feature interactions for the modelling language: that is, we must understand the different ways that feature interactions can manifest among features expressed in the language. The thesis presents a taxonomy of feature interactions for FORML that is an adaptation of existing taxonomies for operational models of feature behaviour. The novelty of the proposed taxonomy is that it presents a definition of behaviour modification that generalizes special cases found in the literature; and it enables feature-interaction analyses that report only unintended interactions, by excluding interactions caused by FORML's constructs for modelling intended feature interactions