Rule Technologies. Research, Tools, and Applications

Picat (picat-lang.org) is a logic-based multi-paradigm programming language that integrates logic programming, functional programming, constraint programming, and scripting. Picat takes many features from other languages, including logic variables, unification, backtracking, pattern-matching rules, functions, list/array comprehensions, loops, assignments, tabling for dynamic programming and planning, and constraint solving with CP (constraint programming), SAT (satisfiability), and MIP (mixed integer programming). These features make Picat more convenient than Prolog for scripting and modeling, and more suitable than functional languages (such as Haskell and F#) and scripting languages (such as Python and Ruby) for symbolic computations. This article provides a quick introduction to Picat using examples from Google Code Jam (GCJ).

The RuleML knowledge-interoperation hub provides for syntactic/semantic representation and internal/external transformation of formal knowledge. The representation system permits the configuration of textbook and enriched Relax NG syntax as well as the association of syntax with semantics. The transformation tool suite includes serialized formatters (normalizers and compactifiers), polarized parsers and generators (the RuleML\(\leftrightarrow \)POSL tool and the RuleML\(\rightarrow \)PSOA/PS generator and PSOA/PS\(\rightarrow \)AST parser), as well as importers and exporters (the importer from Dexlog to Naf Datalog RuleML and the exporter from FOL RuleML languages to TPTP). An N3-PSOA-Flora knowledge-interoperation use case is introduced for illustration.

WorkFlow Management Systems provide automatic support to learn process models or to check compliance of process enactment to correct models. The expressive power of the adopted formalism for representing process models is fundamental to determine the effectiveness or even feasibility of a correct model. In particular, a desirable feature is the possibility of expressing complex conditions on some elements of the model. The formalism used in the WoMan framework for workflow management, based on First-Order Logic, is more expressive than standard formalisms adopted in the literature. It allows tight integration between the activity flow and the conditions, and it allows one to express conditions that take into account contextual information and various kinds of relationships among the involved entities. This paper discusses such a formalism, especially concerning conditions, and provides an explicative example of how this can be applied in practice.

Object-oriented Business Rules Management Systems (OO-BRMS) are a complex applications platform that provide tools for automating day-to-day business decisions. To allow more sophisticated and realistic decision-making, these tools must enable Business Rules (BRs) to handle uncertainties in the domain. For this purpose, several approaches have been proposed, but most of them rely on heuristic models that unfortunately have shortcomings and limitations. In this paper we present a solution allowing modern OO-BRMS to effectively integrate probabilistic reasoning for uncertainty management. This solution has a coupling approach with Probabilistic Relational Models (PRMs) and facilitates the inter-operability, hence, the separation between business and probabilistic logic. We apply our approach to an existing BRMS and discuss implications of the knowledge base dynamicity on the probabilistic inference.

Multi-Context Systems (MCS) model in Computational Logic distributed systems composed of heterogeneous sources, or “contexts”, interacting via special rules called “bridge rules”. In this paper we consider how to enhance flexibility and generality of such systems; in particular, we discuss aspects that might be improved to increase practical applicability.

We develop an approach to compiling high-level specifications of distributed applications into code that is executable on individual computing nodes. The high-level language is a form of multiset rewriting augmented with comprehension patterns. It enables a programmer to describe the behavior of a distributed system as a whole rather than from the perspective of the individual nodes, thus dramatically reducing opportunities for programmer errors. It abstracts away the mechanics of communication and synchronization, resulting in concise and declarative specifications. Compilation generates low-level code in a syntactic fragment of this same formalism. This code forces the point of view of each node, and standard state-of-the-art execution techniques are applicable. It is relatively simple to show the correctness of this compilation scheme.

The paper introduces two connected advancements of Positional-Slotted, Object-Applicative RuleML: (1) a model-theoretic semantics, realized transformationally, that directly handles atoms (i.e., predicate applications) without object identifiers (e.g., relationships as in Prolog) and (2) a transformational semantics that handles nested atomic formulas (e.g., nested frames as in Flora-2/F-logic). For (1), the model theory is extended to atoms with optional OIDs, the transformation is developed from static to dynamic objectification, and the correctness of the realization is proved. For (2), the unnesting transformation is defined to decompose nested atomic formulas into equivalent conjunctions.

Often, we wish to let parties alter or undo a contract that has been made. Toward this end, contract law has developed a set of traditional tools for altering and undoing contracts. Unfortunately, these tools often fail when applied to smart contracts. It is therefore necessary to define a new set of standards for the altering and undoing of smart contracts. These standards might ensure that the tools we use to alter and undo smart contracts achieve their original (contract law) goals when applied to this new technology. This paper develops such a set of standards and, then, to prove their worth as a framework, applies to them to an existing smart contract platform (Ethereum).

While procedural languages are commonly used to program smart contracts in blockchain systems, logic-based languages may be interesting alternatives. In this paper, we inspect what are the possible legal and technical (dis)advantages of logic-based smart contracts in light of common activities featuring ordinary contracts, then we provide insights on how to use such logic-based smart contracts in combination with blockchain systems. These insights lead us to emphasize a fundamental challenge - algorithms for logic approaches have to be efficient, but they also need to be literally cheap as measured within the environment where they are deployed and according to its economic rules. We illustrate this with different algorithms from defeasible logic-based frameworks.

The aims of this paper are to (1) provide a conceptual context for smart contracts, (2) argue that blockchains are a next-generation technology enabling much larger-scale and more complex computing projects, and (3) posit blocktime as a new mode of conceiving time. Blockchains are the distributed ledger technology underlying Bitcoin and other cryptocurrencies; the payments layer the Internet never had; a mechanism for updating truth states in distributed network computing through consensus trust; and overall, a new form of general computational substrate. Blocktime is the time over which a certain number of blocks will have confirmed; and this creates an alternative event trajectory in time which can be offset against human-time or other computing clocktime regimes for arbitrage or complementary purposes. The result of this effort is to show that blocktime allows the contingency of future events to be more robustly orchestrated through temporality as a selectable smart contract feature.

This paper is concerned with rule-based programs that go wrong. The unwanted behavior of rule applications is non-termination or failure of a computation. We propose a static program analysis of the non-termination problem for recursion in the Constraint Handling Rules (CHR) language.

CHR is an advanced concurrent declarative language involving constraint reasoning. It has been closely related to many other rule-based approaches, so the results are of a more general interest. In such languages, non-termination is due to infinite applications of recursive rules. Failure is due to accumulation of contradicting constraints during the computation.

We give theorems with so-called misbehavior conditions for potential non-termination and failure (as well as definite termination) of linear direct recursive simplification rules. Logical relationships between the constraints in a recursive rule play a crucial role in this kind of program analysis. We think that our approach can be extended to other types of recursion and to a more general class of rules. Therefore this paper can serve as a basic reference and a starting point for further research.

Cognitive architectures are used to abstract and simplify the process of computational cognitive modeling. The popular cognitive architecture ACT-R has a well-defined psychological theory, but lacks a formalization of its computational system. This inhibits computational analysis of cognitive models, e.g. confluence or complexity analysis. In this paper we present a source to source transformation of ACT-R models to Constraint Handling Rules (CHR) programs enabling the use of analysis tools for CHR to analyze computational cognitive models. This translation is the first that matches the current abstract operational semantics of ACT-R.

This paper presents an approach for the specification and implementation of translating legal norms represented using LegalRuleML to a variant of Modal Defeasible Logic. From its logical form, legal norms will be transformed into a machine readable format and eventually implemented as executable semantics that can be reasoned about depending upon the client’s preference.

In Ontology Based Data Access (OBDA) users pose SPARQL queries over an ontology that lies on top of relational datasources. These queries are translated on-the-fly into SQL queries by OBDA systems. Standard SPARQL-to-SQL translation techniques in OBDA often produce SQL queries containing redundant joins and unions, even after a number of semantic and structural optimizations. These redundancies are detrimental to the performance of query answering, especially in complex industrial OBDA scenarios with large enterprise databases. To address this issue, we introduce two novel notions of OBDA constraints and show how to exploit them for efficient query answering. We conduct an extensive set of experiments on large datasets using real world data and queries, showing that these techniques strongly improve the performance of query answering up to orders of magnitude.

Due to the increasing availability of huge amounts of data, traditional data management techniques result inadequate in many real life scenarios. Furthermore, heterogeneity and high speed of this data require suitable data storage and management tools to be designed from scratch. In this paper, we describe a framework tailored for analyzing user interactions with intelligent systems while seeking for some domain specific information (e.g., choosing a good restaurant in a visited area). The framework enhances user quest for information by performing a data exchange activity (called data posting) which enriches the information sources with additional background information and knowledge derived from experiences and behavioral properties of domain experts and users.

We introduce intervention optimization as a new area of exploration for data mining research. Interventions are events designed to impact a corresponding time series. The task is to maximize the impact of such events by training a model on historical data. We propose PRIMER as a new regression-rule learning system for identifying sets of event features that maximize impact. PRIMER is for use when domain experts with knowledge of the intervention can specify a transfer function, or the form of the expected response in the time series. PRIMER’s objective function includes the goodness-of-fit of the average response of covered events to the transfer function. Incorporating domain knowledge in this way makes PRIMER robust to over-fitting on noise or spurious responses. PRIMER is designed to produce interpretable results, improving on the interpretability of even competing regression-rule systems for this task. It also has fewer and more intuitive parameters than competing rule-based systems. Empirically, we show that PRIMER is competitive with state-of-the-art regression techniques in a large-scale event study modeling the impact of insider trading on intra-day stock returns.

This paper presents a rule-based approach for both offline and real-time recognition of Activities of Daily Living (ADL), leveraging events produced by a non-intrusive multi-modal sensor infrastructure deployed in a residential environment. Novel aspects of the approach include: the ability to recognise arbitrary scenarios of complex activities using bottom-up multi-level reasoning, starting from sensor events at the lowest level; an effective heuristics-based method for distinguishing between actual and ghost images in video data; and a highly accurate indoor localisation approach that fuses different sources of location information. The proposed approach is implemented as a rule-based system using Jess and is evaluated using data collected in a smart home environment. Experimental results show high levels of accuracy and performance, proving the effectiveness of the approach in real world setups.

To automate assisted living tasks in smart environments, the contextual and temporal aspects associated with activities of daily life (ADL) can be exploited to (1) detect and act upon inconsistent context, i.e., when an activity occurs outside of its usual context; and (2) guidance through ADL routines, by automatically executing or suggesting a next subtask at the correct context. This paper presents SmartRL, a context-sensitive rule language supporting task automation in smart environments, and applies it to an Assisted Ambient Living (AAL) use case. SmartRL realizes a number of key opportunities in this setting, such as linking the language to a domain ontology, and facilitating the detection and influencing of context; as well as considering the temporal nature of smart environment rules, the need to revert rule effects, and writing activity routines.