Declarative Framework Research Articles

Towards declarative comparabilities: Application to functional dependencies

In real life, data are often of poor quality as a result, for instance, of uncertainty, mismeasurements, missing values or bad inputs. This issue hampers an implicit yet crucial operation of every database management system: equality testing. Indeed, equality is, in the end, a context-dependent operation with a plethora of interpretations. In practice, the treatment of different types of equality is left to programmers, who have to struggle with those interpretations in their code. We introduce a lattice-based declarative framework to address this problem. It allows specification of numerous semantics for equality at a high level of abstraction. To go beyond tuple equality, we study functional dependencies (FDs) in the light of our framework. First, we define abstract FDs, generalizing classical FDs. These lead to the consideration of particular interpretations of equality: realities. Building upon realities and possible/certain answers, we introduce possible/certain FDs and give some complexity results.

Sharing Queries with Nonequivalent User-defined Aggregate Functions

This article presents Sharing User-Defined Aggregate Function (SUDAF), a declarative framework that allows users to write User-defined Aggregate Functions (UDAFs) as mathematical expressions and use them in Structured Query Language statements. SUDAF rewrites partial aggregates of UDAFs using built-in aggregate functions and supports efficient dynamic caching and reusing of partial aggregates. Our experiments show that rewriting UDAFs using built-in functions can significantly speed up queries with UDAFs, and the proposed sharing approach can yield up to two orders of magnitude improvement in query execution time. The article studies also an extension of SUDAF to support sharing partial results between arbitrary queries with UDAFs. We show a connection with the problem of query rewriting using views and introduce a new class of rewritings, called SUDAF rewritings, which enables to use views that have aggregate functions different from the ones used in the input query. We investigate the underlying rewriting-checking and rewriting-existing problem. Our main technical result is a reduction of these problems to, respectively, rewriting-checking and rewriting-existing of the so-called aggregate candidates , a class of rewritings that has been deeply investigated in the literature.

Relational Programming with Foundational Models

Foundation models have vast potential to enable diverse AI applications. The powerful yet incomplete nature of these models has spurred a wide range of mechanisms to augment them with capabilities such as in-context learning, information retrieval, and code interpreting. We propose Vieira, a declarative framework that unifies these mechanisms in a general solution for programming with foundation models. Vieira follows a probabilistic relational paradigm and treats foundation models as stateless functions with relational inputs and outputs. It supports neuro-symbolic applications by enabling the seamless combination of such models with logic programs, as well as complex, multi-modal applications by streamlining the composition of diverse sub-models. We implement Vieira by extending the Scallop compiler with a foreign interface that supports foundation models as plugins. We implement plugins for 12 foundation models including GPT, CLIP, and SAM. We evaluate Vieira on 9 challenging tasks that span language, vision, and structured and vector databases. Our evaluation shows that programs in Vieira are concise, can incorporate modern foundation models, and have comparable or better accuracy than competitive baselines.

Seeking a safe and efficient similarity-based unfolding rule

The unfolding transformation has been widely used in many declarative frameworks for improving the efficiency of programs. Inspired by our previous experiences in fuzzy logic languages that do not deal with similarity relations, in this work we try to adapt such operation to the framework of the fuzzy logic programming language FASILL (acronym of “Fuzzy Aggregators and Similarity Into a Logic Language”) which has been developed in our research group for coping with implicit/explicit truth degree annotations, a great variety of connectives and unification by similarity. The traditional unfolding transformation is based on the application of unifiers on the heads and computational steps on the bodies of program rules. However, when considering similarity relations, the premature generation and application of weak (similarity-based) unifiers at unfolding time could destroy the correctness (i.e., the soundness and completeness) of the transformation. In this paper we study how to avoid the risk, by imposing some conditions on programs in order to be safely unfolded. We show that these conditions are sufficient to guarantee the correctness of the unfolding transformation, and we present some experiments performed with the implemented online tool for illustrating the improved efficiency of unfolded programs.

A Semantic Framework for Decision Making in Forest Fire Emergencies

Forest fires can have devastating effects on the environment, communities, individuals, economy, and climate change in many countries. During a forest fire crisis, massive amounts of data, such as weather patterns and soil conditions, become available. Efficient management, intelligent integration, and processing the available information in order to extract useful insights and knowledge to facilitate advanced whereas and support human operators and authorities in a real operational scenario is a challenge. In this work, we present ONTO-SAFE, an ontology-based framework for wildfire events, adopting Semantic Web technologies for data integration and infusion of domain and background knowledge. More specifically, the framework creates a unified representation of the available assets, taking into account data generated from different sources, such as sensors, weather forecasts, earth observations, etc. To this end, previously existing ontologies and standards are used, such as Empathi and EmergencyFire ontology, to provide the conceptual model and the necessary level of abstraction in the form of interconnected knowledge graphs to satisfy the modeling requirements. On top of the generated knowledge graphs, a declarative framework extracts facts and higher-level inferred knowledge from asserted data to support users in decision making. In addition, the framework supports the generation of recommendations, such as sharing important wildfire information with citizens and professionals, that can be adjusted based on user-defined factors and the current disaster risk management phase.

Formal Validation of Software for Nano Satellite Missions

Space research industry has become one of the most successful domains in the last years. In particular, the development of nano satellites has emerged as a stunning field since its low costs of production. The software in charge of the satellite functioning must be carefully verified to check that system fulfills the expected behavior. In this work we provide a full, complete and declarative framework to formally validate software for nano satellite missions, including behavioral synthesis which is a distinguishable contribution in this field. When validating the satellite behavior we include requirements from different sources: on board computer, IoT protocols, operating system and mission properties. Our framework is based on the declarative and graphical language FVS (Feather Weight Visual Scenarios).

Exploiting Structure in Regular Expression Queries

Regular expression, or regex, is widely used to extract critical information from a large corpus of formatted text by finding patterns of interest. In tasks like log processing, the speed of regex matching is crucial. Data scientists and developers regularly use regex libraries that implement optimized regular expression matching using modern automata theory. However, computing state transitions in the underlying regex evaluation engine can be inefficient when a regex query contains a multitude of string literals. This inefficiency is further exasperated when analyzing large data volumes. This paper presents BLARE, Blazingly Fast Regular Expression, a regular expression matching framework that is inspired by the mechanisms that are used in database engines, which use a declarative framework to explore multiple equivalent execution plans, all of which produce the correct final result. Similarly, BLARE decomposes a regex into multiple regex and string components and then creates evaluation strategies in which the components can be evaluated in an order that is not strictly a left-to-right translation of the input regex query. Rather than using a cost-based optimization approach, BLARE uses an adaptive runtime strategy based on a multi-armed bandit approach to find an efficient execution plan. BLARE is also modular and can be built on top of any existing regex library. We implemented BLARE on four commonly used regex libraries, RE2, PCRE2, Boost Regex, and ICU Regex, and evaluated it using two production workloads and one open-source workload. BLARE was 1.6× to 3.7× faster than RE2 and 3.4× to 7.9× faster than Boost Regex. PCRE2 did not finish on one of the workloads, but on the remaining two workloads, BLARE improved the performance of PCRE2 by 3.1× to over 100×. For the open-source dataset, BLARE provided a speed up of 61.7× for ICU Regex. BLARE code is publicly available at https://github.com/mush-zhang/Blare.

Sustainable goal-oriented smart environments: a declarative programming approach

Abstract The sustainable management of smart environments enabled by the Internet of Things (IoT) requires new methodologies and tools to suitably handle potentially many users and their objectives on cyber-physical systems, e.g. smart lighting, smart A/C. In this article, we propose a declarative framework to model IoT-enabled smart environments. Our methodology permits (i) expressing user roles and hierarchical environments, (ii) declaring customized policies to mediate user objectives into a target state and (iii) determining valid settings for IoT actuators to achieve such a target also reducing energy consumption. An open-source Prolog prototype of the framework is showcased over two lifelike motivating examples and its scalability is assessed at increasing sizes of the managed smart environment.

DIEL: Interactive Visualization Beyond the Here and Now.

Interactive visualization design and research have primarily focused on local data and synchronous events. However, for more complex use cases-e.g., remote database access and streaming data sources-developers must grapple with distributed data and asynchronous events. Currently, constructing these use cases is difficult and time-consuming; developers are forced to operationally program low-level details like asynchronous database querying and reactive event handling. This approach is in stark contrast to modern methods for browser-based interactive visualization, which feature high-level declarative specifications. In response, we present DIEL, a declarative framework that supports asynchronous events over distributed data. As in many declarative languages, DIEL developers specify only what data they want, rather than procedural steps for how to assemble it. Uniquely, DIEL models asynchronous events (e.g., user interactions, server responses) as streams of data that are captured in event logs. To specify the state of a visualization at any time, developers write declarative queries over the data and event logs; DIEL compiles and optimizes a corresponding dataflow graph, and automatically generates necessary low-level distributed systems details. We demonstrate DIEL'S performance and expressivity through example interactive visualizations that make diverse use of remote data and asynchronous events. We further evaluate DIEL'S usability using the Cognitive Dimensions of Notations framework, revealing wins such as ease of change, and compromises such as premature commitments.

Osmotic management of distributed complex systems: A declarative decentralised approach

AbstractOsmotic computing encompasses emerging Cloud‐Internet of Things (IoT) computing paradigms, by featuring the possibility for application services to adapt into different functionally equivalent flavours, depending on the contextually available resources and on specific requirements of running applications. This article proposes a fully decentralised declarative framework that enables both application and infrastructure operators to declare management policies for the service instances and the nodes they manage, respectively. Policies are composed of a simple and well‐defined set of management operations, declared in Prolog, which trigger based on locally available contextual information on application requests and infrastructure resources. A prototype implementation of the framework is showcased and assessed via simulation over a lifelike Smart Campus use case with multiple applications, at increasing infrastructure sizes and number of mobile users. Experimental results show that the proposed management framework scales to large infrastructure sizes and suits the needs of multiflavoured Osmotic applications in dynamic deployment conditions, by improving the trade‐off between their response times and suitable service usage.

Declarative data serving

Recent advances in computer architecture and networking have ushered in a new age of edge computing, where computation is placed close to the point of data collection to facilitate low-latency decision making. As the complexity of such deployments grow into networks of interconnected edge devices, getting the necessary data to be in "the right place at the right time" can become a challenge. We envision a future of edge analytics where data flows between edge nodes are declaratively configured through high-level constraints. Using machine learning model-serving as a prototypical task, we illustrate how the heterogeneity and specialization of edge devices can lead to complex, task-specific communication patterns even in relatively simple situations. Without a declarative framework, managing this complexity will be challenging for developers and will lead to brittle systems. We conclude with a research vision for database community that brings our perspective to the emergent area of edge computing.

Modeling Content and Context with Deep Relational Learning

Building models for realistic natural language tasks requires dealing with long texts and accounting for complicated structural dependencies. Neural-symbolic representations have emerged as a way to combine the reasoning capabilities of symbolic methods, with the expressiveness of neural networks. However, most of the existing frameworks for combining neural and symbolic representations have been designed for classic relational learning tasks that work over a universe of symbolic entities and relations. In this paper, we present DRaiL, an open-source declarative framework for specifying deep relational models, designed to support a variety of NLP scenarios. Our framework supports easy integration with expressive language encoders, and provides an interface to study the interactions between representation, inference and learning.

A competency-driven staff assignment approach to improving employee scheduling robustness

Presented paper concerns the competency-driven staff assignment and scheduling approach to the management of project portfolios subject to perturbations caused by employee absences and/or unexpected arrival of high priority jobs. Proactive strategy is considered, which exploits the concept of employee substitutability to improve the robustness of personnel allocation in the case of occurrence of specific types of disruptions. Solutions obtained using the model of a constraint satisfaction problem developed in this study are validated in series quantitative and qualitative experiments. With a view to future implementation in a Decision Support Systems dedicated to prototyping of proactive personnel allocation, a methodology employing the concept of a competency framework-based robustness measure is proposed. Implemented in a declarative framework, the proposed approach allows one to find a redundant competency framework robust to a given set of disruptions.

Protocol combinators for modeling, testing, and execution of distributed systems

Abstract Distributed systems are hard to get right, model, test, debug, and teach. Their textbook definitions, typically given in a form of replicated state machines, are concise, yet prone to introducing programming errors if naïvely translated into runnable implementations. In this work, we present Distributed Protocol Combinators (DPC), a declarative programming framework that aims to bridge the gap between specifications and runnable implementations of distributed systems, and facilitate their modeling, testing, and execution. DPC builds on the ideas from the state-of-the art logics for compositional systems verification. The contribution of DPC is a novel family of program-level primitives, which facilitates construction of larger distributed systems from smaller components, streamlining the usage of the most common asynchronous message-passing communication patterns, and providing machinery for testing and user-friendly dynamic verification of systems. This paper describes the main ideas behind the design of the framework and presents its implementation in Haskell. We introduce DPC through a series of characteristic examples and showcase it on a number of distributed protocols from the literature. This paper extends our preceeding conference publication (Andersen & Sergey, 2019a) with an exploration of randomized testing for protocols and their implementations, and an additional case study demonstrating bounded model checking of protocols.

Ontology-based Document Spanning Systems for Information Extraction

Information Extraction (IE) is the task of automatically organizing in a structured form data extracted from free text documents. In several contexts, it is often desirable that the extracted data are then organized according to an ontology, which provides a formal and conceptual representation of the domain of interest. Ontologies allow for a better data interpretation, as well as for their semantic integration with other information, as in Ontology-based Data Access (OBDA), a popular declarative framework for data management where an ontology is connected to a data layer through mappings. However, the data layer considered so far in OBDA has consisted essentially of relational databases, and how to declaratively couple an ontology with unstructured data sources is still unexplored. By leveraging the recent study on document spanners for rule-based IE by Fagin et al., in this paper, we propose a new framework that allows to map text documents to ontologies, in the spirit of OBDA. We investigate the problem of answering conjunctive queries in this framework. For ontologies specified in the Description Logics [Formula: see text] and [Formula: see text], we show that the problem is polynomial in the size of the underlying documents. We also provide algorithms to solve query answering by rewriting the input query on the basis of the ontology and its mapping toward the source documents. Through these techniques, we pursue a virtual approach, similar to that typically adopted in OBDA, which allows us to answer a query without having to first populate the entire ontology. Interestingly, for [Formula: see text], both the spanners used in the mapping and the one computed by the rewriting algorithm belong to the same class of expressiveness. This holds also for [Formula: see text], modulo some limitations on the form of the mapping. These results say that in these cases our framework can be easily implemented by decoupling ontology management and document access, which can be delegated to an external IE system able to process the extraction rules we use in the mapping.

Data Analysis using ALICE Run 3 Framework

The ALICE Experiment is currently undergoing a major upgrade program, both in terms of hardware and software, to prepare for the LHC Run 3. A new Software Framework is being developed in collaboration with the FAIR experiments at GSI to cope with the 100-fold increase in the number of recorded events. We present our progress to adapt such a framework for the end user physics data analysis. In particular, the design and technology choices are highlighted. How Apache Arrow is adopted as the platform for the in-memory analysis data layout is discussed. The benefits of this solution are illustrated, these include: efficient and parallel data processing, interoperability with a large number of analysis tools and ecosystems, integration with the modern ROOT declarative analysis framework RDataFrame.

Weak persistency semantics from the ground up: formalising the persistency semantics of ARMv8 and transactional models

Emerging non-volatile memory (NVM) technologies promise the durability of disks with the performance of volatile memory (RAM). To describe the persistency guarantees of NVM, several memory persistency models have been proposed in the literature. However, the formal persistency semantics of mainstream hardware is unexplored to date. To close this gap, we present a formal declarative framework for describing concurrency models in the NVM context, and then develop the PARMv8 persistency model as an instance of our framework, formalising the persistency semantics of the ARMv8 architecture for the first time. To facilitate correct persistent programming, we study transactions as a simple abstraction for concurrency and persistency control. We thus develop the PSER (persistent serialisability) persistency model, formalising transactional semantics in the NVM context for the first time, and demonstrate that PSER correctly compiles to PARMv8. This then enables programmers to write correct, concurrent and persistent programs, without having to understand the low-level architecture-specific persistency semantics of the underlying hardware.

A logical framework for view updating in indefinite databases

AbstractThis paper introduces and studies a declarative framework for updating views over indefinite databases. An indefinite database is a database with null values that are represented, following the standard database approach, by a single null constant. Typically a database is represented by a single set of facts $D$ that model what is known to be true. This paper proposes a model of an indefinite extensional database that is more expressive with respect to the closed-world assumption (CWA) adapted for the setting of indefinite databases (Libkin, 1995, A semantics-based approach to design of query languages for partial information. In Semantics in Databases, vol. 1358 of LNCS, pp. 170–208. Springer; der Meyden, 1998, Logical approaches to incomplete information: a survey. In Logics for Databases and Information Systems, pp. 307–356. Kluwer Academic Publishers, Norwell, MA, USA). More specifically, in our model, databases are determined by two sets of facts: $D$ representing, as usual, all facts that are true in the database, and $E$ that is meant to represent exceptions to the ‘unknown range’, i.e. facts that cannot be unknown. Intuitively, unless they are explicitly implied to be true by the first set, the facts specified as exceptions are assumed false. The semantics is given by means of a two-level CWA tailored to the case of indefinite information. The paper characterizes the semantics of indefinite databases in terms of their possible worlds that are obtained by instantiating occurrences of null values by concrete constants and defines several classes of database repairs that realize view-update requests. Most notable is the class of constrained repairs. Constrained repairs change the database ‘minimally’and avoid making arbitrary commitments. They narrow down the space of alternative ways to fulfill the view-update request to those that are grounded, in a certain strong sense, in the database, the view and the view-update request.

Nurse (Re)scheduling via answer set programming1

The goal of the Nurse Scheduling Problem is to find an assignment of nurses to shifts according to specific requirements. Frequently, a computed schedule may become not usable because of sudden absences of some nurses. In this cases, Nurse Rescheduling amounts to the computation of a new schedule, which has to satisfy the original requirements and the new absences. Additionally, a good solution to the Nurse Rescheduling Problem must be as similar as possible to the original schedule, which practically means that the number of changes has to be minimized. This paper focuses on the requirements specified by an Italian hospital, and recently addressed by an approach based on Answer Set Programming (ASP). Even if promising results have been obtained with ASP, the original encoding presents some intrinsic weaknesses, which are identified and eventually circumvented in this paper. The new encoding is designed by taking into account both intrinsic properties of Nurse Scheduling and internal details of ASP solvers, such as cardinality and weight constraint propagators. The performance gain of clingo and wasp is empirically verified on instances from ASP literature. As an additional contribution, the performance of clingo and wasp is compared to other declarative frameworks, namely SAT and ILP; the best performance is obtained by clingo running the new ASP encoding. The advanced ASP encodings are then extended to solve Nurse Rescheduling, and an empirical evaluation is conducted with clingo and wasp.

On library correctness under weak memory consistency: specifying and verifying concurrent libraries under declarative consistency models

Concurrent libraries are the building blocks for concurrency. They encompass a range of abstractions (locks, exchangers, stacks, queues, sets) built in a layered fashion: more advanced libraries are built out of simpler ones. While there has been a lot of work on verifying such libraries in a sequentially consistent (SC) environment, little is known about how to specify and verify them under weak memory consistency (WMC). We propose a general declarative framework that allows us to specify concurrent libraries declaratively, and to verify library implementations against their specifications compositionally. Our framework is sufficient to encode standard models such as SC, (R)C11 and TSO. Additionally, we specify several concurrent libraries, including mutual exclusion locks, reader-writer locks, exchangers, queues, stacks and sets. We then use our framework to verify multiple weakly consistent implementations of locks, exchangers, queues and stacks.