Aggregation Semantics Research Articles

Aggregate Semantics for Propositional Answer Set Programs

AbstractAnswer set programming (ASP) emerged in the late 1990s as a paradigm for knowledge representation and reasoning. The attractiveness of ASP builds on an expressive high-level modeling language along with the availability of powerful off-the-shelf solving systems. While the utility of incorporating aggregate expressions in the modeling language has been realized almost simultaneously with the inception of the first ASP solving systems, a general semantics of aggregates and its efficient implementation have been long-standing challenges. Aggregates have been proposed and widely used in database systems, and also in the deductive database language Datalog, which is one of the main precursors of ASP. The use of aggregates was, however, still restricted in Datalog (by either disallowing recursion or only allowing monotone aggregates), while several ways to integrate unrestricted aggregates evolved in the context of ASP. In this survey, we pick up at this point of development by presenting and comparing the main aggregate semantics that have been proposed for propositional ASP programs. We highlight crucial properties such as computational complexity and expressive power, and outline the capabilities and limitations of different approaches by illustrative examples.

Copula-based software metrics aggregation

A quality model is a conceptual decomposition of an abstract notion of quality into relevant, possibly conflicting characteristics and further into measurable metrics. For quality assessment and decision making, metrics values are aggregated to characteristics and ultimately to quality scores. Aggregation has often been problematic as quality models do not provide the semantics of aggregation. This makes it hard to formally reason about metrics, characteristics, and quality. We argue that aggregation needs to be interpretable and mathematically well defined in order to assess, to compare, and to improve quality. To address this challenge, we propose a probabilistic approach to aggregation and define quality scores based on joint distributions of absolute metrics values. To evaluate the proposed approach and its implementation under realistic conditions, we conduct empirical studies on bug prediction of ca. 5000 software classes, maintainability of ca. 15000 open-source software systems, and on the information quality of ca. 100000 real-world technical documents. We found that our approach is feasible, accurate, and scalable in performance.

A Permissioned Blockchain Network for Security and Sharing of De-identified Tuberculosis Research Data in Brazil.

Tuberculosis (TB) is an infectious disease and is among the top 10 causes of death in the world, and Brazil is part of the top 30 high TB burden countries. Data collection is an essential practice in health studies, and the adoption of electronic data capture (EDC) systems can positively increase the experience of data acquisition and analysis. Also, data-sharing capabilities are crucial to the construction of efficient and effective evidence-based decision-making tools for managerial and operational actions in TB services. Data must be held secure and traceable, as well as available and understandable, for authorized parties. In this sense, this work aims to propose a blockchain-based approach to build a reusable, decentralized, and de-identified dataset of TB research data, while increasing transparency, accountability, availability, and integrity of raw data collected in EDC systems. After identifying challenges and gaps, a solution was proposed to tackle them, considering its relevance for TB studies. Data security issues are being addressed by a blockchain network and a lightweight and practical governance model. Research Electronic Data Capture (REDCap) and KoBoToolbox are used as EDC systems in TB research. Mechanisms to de-identify data and aggregate semantics to data are also available. A permissioned blockchain network was built using Kaleido platform. An integration engine integrates the EDC systems with the blockchain network, performing de-identification and aggregating meaning to data. A governance model addresses operational and legal issues for the proper use of data. Finally, a management system facilitates the handling of necessary metadata, and additional applications are available to explore the blockchain and export data. Research data are an important asset not only for the research where it was generated, but also to underpin studies replication and support further investigations. The proposed solution allows the delivery of de-identified databases built in real time by storing data in transactions of a permissioned network, including semantic annotations, as data are being collected in TB research. The governance model promotes the correct use of the solution.

From distributed coordination to field calculus and aggregate computing

Aggregate computing is an emerging approach to the engineering of complex coordination for distributed systems, based on viewing system interactions in terms of information propagating through collectives of devices, rather than in terms of individual devices and their interaction with their peers and environment. The foundation of this approach is the distillation of a number of prior approaches, both formal and pragmatic, proposed under the umbrella of field-based coordination, and culminating into the field calculus, a universal functional programming model for the specification and composition of collective behaviours with equivalent local and aggregate semantics. This foundation has been elaborated into a layered approach to engineering coordination of complex distributed systems, building up to pragmatic applications through intermediate layers encompassing reusable libraries of program components. Furthermore, some of these components are formally shown to satisfy formal properties like self-stabilisation, which transfer to whole application services by functional composition. In this survey, we trace the development and antecedents of field calculus, review the field calculus itself and the current state of aggregate computing theory and practice, and discuss a roadmap of current research directions with implications for the development of a broad range of distributed systems.

Lumpability abstractions of rule-based systems

The induction of a signaling pathway is characterized by transient complex formation and mutual posttranslational modification of proteins. To faithfully capture this combinatorial process in a mathematical model is an important challenge in systems biology. Exploiting the limited context on which most binding and modification events are conditioned, attempts have been made to reduce the combinatorial complexity by quotienting the reachable set of molecular species into species aggregates while preserving the deterministic semantics of the thermodynamic limit. Recently, we proposed a quotienting that also preserves the stochastic semantics and that is complete in the sense that the semantics of individual species can be recovered from the aggregate semantics. In this paper, we prove that this quotienting yields a sufficient condition for weak lumpability (that is to say that the quotient system is still Markovian for a given set of initial distributions) and that it gives rise to a backward Markov bisimulation between the original and aggregated transition system (which means that the conditional probability of being in a given state in the original system knowing that we are in its equivalence class is an invariant of the system). We illustrate the framework on a case study of the epidermal growth factor (EGF)/insulin receptor crosstalk.

Logic programs with propositional connectives and aggregates

Answer set programming (ASP) is a logic programming paradigm that can be used to solve complex combinatorial search problems. Aggregates are an ASP construct that plays an important role in many applications. Defining a satisfactory semantics of aggregates turned out to be a difficult problem, and in this article we propose a new approach, based on an analogy between aggregates and propositional connectives. First we extend the definition of an answer set/stable model to cover arbitrary propositional theories; then we define aggregates on top of them both as primitive constructs and as abbreviations for formulas. Our definition of an aggregate combines expressiveness and simplicity, and it inherits many theorems about programs with nested expressions, such as theorems about strong equivalence and splitting.

Lumpability Abstractions of Rule-based Systems

The induction of a signaling pathway is characterized by transient complex formation and mutual posttranslational modification of proteins. To faithfully capture this combinatorial process in a mathematical model is an important challenge in systems biology. Exploiting the limited context on which most binding and modification events are conditioned, attempts have been made to reduce the combinatorial complexity by quotienting the reachable set of molecular species, into species aggregates while preserving the deterministic semantics of the thermodynamic limit. Recently we proposed a quotienting that also preserves the stochastic semantics and that is complete in the sense that the semantics of individual species can be recovered from the aggregate semantics. In this paper we prove that this quotienting yields a sufficient condition for weak lumpability and that it gives rise to a backward Markov bisimulation between the original and aggregated transition system. We illustrate the framework on a case study of the EGF/insulin receptor crosstalk.

Semantics and complexity of recursive aggregates in answer set programming

The addition of aggregates has been one of the most relevant enhancements to the language of answer set programming (ASP). They strengthen the modelling power of ASP in terms of natural and concise problem representations. Previous semantic definitions typically agree in the case of non-recursive aggregates, but the picture is less clear for aggregates involved in recursion. Some proposals explicitly avoid recursive aggregates, most others differ, and many of them do not satisfy desirable criteria, such as minimality or coincidence with answer sets in the aggregate-free case. In this paper we define a semantics for programs with arbitrary aggregates (including monotone, antimonotone, and nonmonotone aggregates) in the full ASP language allowing also for disjunction in the head (disjunctive logic programming — DLP). This semantics is a genuine generalization of the answer set semantics for DLP, it is defined by a natural variant of the Gelfond–Lifschitz transformation, and treats aggregate and non-aggregate literals in a uniform way. This novel transformation is interesting per se also in the aggregate-free case, since it is simpler than the original transformation and does not need to differentiate between positive and negative literals. We prove that our semantics guarantees the minimality (and therefore the incomparability) of answer sets, and we demonstrate that it coincides with the standard answer set semantics on aggregate-free programs. Moreover, we carry out an in-depth study of the computational complexity of the language. The analysis pays particular attention to the impact of syntactical restrictions on programs in the form of limited use of aggregates, disjunction, and negation. While the addition of aggregates does not affect the complexity of the full DLP language, it turns out that their presence does increase the complexity of normal (i.e., non-disjunctive) ASP programs up to the second level of the polynomial hierarchy. However, we show that there are large classes of aggregates the addition of which does not cause any complexity gap even for normal programs, including the fragment allowing for arbitrary monotone, arbitrary antimonotone, and stratified (i.e., non-recursive) nonmonotone aggregates. The analysis provides some useful indications on the possibility to implement aggregates in existing reasoning engines.

Object-extended OLAP querying

On-line analytical processing (OLAP) systems based on a dimensional view of data have found widespread use in business applications and are being used increasingly in non-standard applications. These systems provide good performance and ease-of-use. However, the complex structures and relationships inherent in data in non-standard applications are not accommodated well by OLAP systems. In contrast, object database systems are built to handle such complexity, but do not support OLAP-type querying well. This paper presents the concepts and techniques underlying a flexible, “multi-model” federated system that enables OLAP users to exploit simultaneously the features of OLAP and object systems. The system allows data to be handled using the most appropriate data model and technology: OLAP systems for dimensional data and object database systems for more complex, general data. This allows data analysis on the OLAP data to be significantly enriched by the use of additional object data. Additionally, physical integration of the OLAP and the object data can be avoided. As a vehicle for demonstrating the capabilities of the system, a prototypical OLAP language is defined and extended to naturally support queries that involve data in object databases. The language permits selection criteria that reference object data, queries that return combinations of OLAP and object data, and queries that group dimensional data according to object data. The system is designed to be aggregation-safe, in the sense that it exploits the aggregation semantics of the data to prevent incorrect or meaningless query results. These capabilities may also be integrated into existing languages. It is shown how to integrate relational and XML data using the technology. A prototype implementation of the system is reported, along with performance measurements that show that the approach is a viable alternative to a physically integrated data warehouse.

Recovering UML class models from C++: A detailed explanation

An approach to recovering design-level UML class models from C++ source code to support program comprehension is presented. A set of mappings are given that focus on accurately identifying such elements as relationship types, multiplicities, and aggregation semantics. These mappings are based on domain knowledge of the C++ language and common programming conventions and idioms. Additionally, formal concept analysis is used to detect design-level attributes of UML classes. An application implementing these mappings is used to reverse engineer a moderately sized, open-source application and the resultant class model is compared against those produced by other UML reverse engineering tools. This comparison shows that the presented mapping rules effectively produce meaningful and semantically accurate UML models.

Translating relational schema into XML schema definition with data semantic preservation and XSD graph

Many legacy systems have been created by using relational database operating not for the Internet expression. Since the relational database is not an efficient way for data explosion, electronic transfer of data, and electronic business on the Web, we introduce a methodology in which a relational schema will be translated to an Extensible Markup Language (XML) schema definition for creating an XML database that is a simple and efficient format on the Web. We apply the Indirect Schema Translation Method that is a semantic-based methodology in this project. The mechanism is that the Relational Schema will be translated into the conceptual model, an Extended Entity Relationship (EER) Model using Reverse Engineering. Afterward, the EER model will be mapped to an XML Schema Definition Language (XSD) Graph as an XML conceptual schema using Semantic Transformation. Finally, the XSD Graph will be mapped into the XSD as an XML logical schema in the process of Forward Engineering, and the data semantics of participation, cardinality, generalization, aggregation, categorization, N-ary and U-ary relationship are preserved in the translated XML schema definition.

The whole-part relationship in object modelling: a definition in cOlOr

In object models built according to popular object-oriented formalisms, the commonest relationship types (excluding inheritance) are the structural relationships of association and of whole-part (often called aggregation). This last type is well known to have no accurately prescribed semantics. Here, some of the aggregation semantics frequently presented in the literature and sometimes supported in current object-oriented modelling languages, especially UML, are analysed and criticised. Because of defects, the use of a modelling notation based on these aggregation semantics is dubious and limited. Moreover, many properties are candidates for characterising the whole-part relationship provided that no redundancy and no inconsistency exist between them. A framework known as cOlOr is then offered by means of a metamodel in which the Whole-Part metatype inherits from the Structural-Relationship metatype. Defining a specific aggregation semantics leads then, first, within cOlOr, to the creation of a subtype of the Whole-Part metatype. Next, the behaviour of this last type is extended and/or restricted in using a constraint-based approach. Such a process is developed particularly for considering Composition in UML and Aggregation in OML more formally, as well as for dealing with domain-dependent aggregation semantics. Since a non-negligible feature of cOlOr is the availability of a C++ library that implements the proposed metamodel, some implementation concerns are also briefly discussed.

A logical design method for relational databases based on generalization and aggregation semantics

In this paper, a series of design methods for relational databases based on generalization and aggregation semantics is set up. The relationship between a class and its subclass is considered as a scheme constraint. The concept of inheritance dependencies, which describes the multiple inheritance among schemes, is presented in the paper. It is shown that the inference rules for inheritance dependencies are sound and complete. Furthermore, a series of results about the closure of inheritance dependencies and the minimal set of inheritance dependencies, which are analogues to functional dependencies, is obtained. In order to describe the aggregation semantics, the concept of aggregation dependencies is given. It is easy to implement these constraints under relational database management systems.

Modelling constraints in part structures

Data modelling plays a pivotal role in Computer Integrated Manufacturing (CIM) as a vehicle for integration among the various component systems and users. Standardization in the representation of product information is receiving growing attention in recent years. In data modelling, the concepts of generalization, aggregation and classification are well known. They form the foundation of many, if not most, semantic and object-oriented models. Class hierarchy and the attendant inheritance semantics provide powerful modelling mechanisms whereby a more effective schema can be constructed in which common structural and behavioural specifications are shared. Aggregation has mainly been treated as an information structuring concept in most models, with focus on how complex-valued properties can be accommodated. In the application of computers in such areas as CAD/CAM and Geographic Information Systems where the structure of objects is of primary importance, the current aggregation semantics are inadequate. In this paper, we examine the aggregation concept from a number of perspectives. We discuss a proposed model of attribute semantics which can more effectively support the definition of constraints and derived data in an aggregation hierarchy. In the model, object attributes are categorized according to their meronymic type. The attribute categories serve as expansion scope for generating attribute references on a composite object. In the latter part of the paper we illustrate how part-of semantics can be incorporated into the current international standard for manufacturing data exchange of STEP/EXPRESS.

Object inheritance beyond subtyping

A categorial semantic domain for objects is presented in order to clarify both aggregation and specialization. Three kinds of specialization are discussed: (1) subtyping (specialization with no side effects and no non-monotonic overriding); (2) monotonic specialization (possibly with side effects but still only with monotonic overriding); and (3) non-monotonic specialization (possibly with side effects and non-monotonic overriding). A sequence of three categories of objects differing only in the morphisms is presented. The first one is used to explain object aggregation (respecting locality through a frame constraint) and the strictest form of specialization (subtyping). The second category is shown to be adequate for explaining specialization with side effects (by relaxing the frame constraint). Finally, the third category supports also non-monotonic overriding, by adopting as morphisms suitable partial morphisms of the second one. All these categories are complete and cocomplete. Colimits are used for explaining the semantics of aggregation and multiple inheritance.

An object-oriented approach to multimedia databases

This paper identifies data modelling and data access and sharing requirements which multimedia applications impose on a database system. It shows the capabilities of an object-based data model and indicates extensions which are needed to meet the data modelling aspects of these requirements. A logical implementation of the operations on the model is described. The model generalizes the notions of instantiation and generalization in the standard object-oriented paradigm, and augments it with the notions of aggregation and relationships which are specialized for a multimedia application environment. Objects may exist in aggregation hierarchies which provide the capability to integrate diverse types of multimedia information such as text, sound, bit-mapped images, and complex graphics drawings. Objects may also be linked through other user-defined relationships to capture such application functions as voice annotation and referencing of one document by another. Using this model, the semantics of aggregation and relationships in a multimedia application environment can be understood and efficiently supported by a database system.