Aggregates are commonplace in database query languages. It is natural to include them also into logic programming. However, doing so raises a number of issues, in particular when aggregates are used in conjunction with recursive definitions. This talk will shed some light on the underlying issues and some of the solutions proposed in the literature so far.
Search and Optimization Strategies
Topics:
Definitions
Branch & Bound
Greedy
Local Search
Teaching material for the course of "Tecniche di Programmazione" at Politecnico di Torino in year 2012/2013. More information: http://bit.ly/tecn-progr
This presentation will introduce you to programming languages that support different programming paradigms and to give you the knowledge of basic concepts and techniques that will allow them to differentiate between various programming paradigms.
Incremental View Maintenance for openCypher QueriesGábor Szárnyas
Presented at the Fourth openCypher Implementers Meeting
Numerous graph use cases require continuous evaluation of queries over a constantly changing data set, e.g. fraud detection in financial systems, recommendations, and checking integrity constraints. For relational systems, incremental view maintenance has been researched for three decades, resulting in a wide body of literature. The property graph data model and the openCypher language, however, are recent developments, and therefore lack established techniques to perform efficient view maintenance. In this talk, we give an overview of the view maintenance problem for property graphs, discuss why it is particularly difficult and present an approach that tackles a meaningful subset of the language.
What Is Dynamic Programming? | Dynamic Programming Explained | Programming Fo...Simplilearn
This presentation on 'What Is Dynamic Programming?' will acquaint you with a clear understanding of how this programming paradigm works with the help of a real-life example. In this Dynamic Programming Tutorial, you will understand why recursion is not compatible and how you can solve the problems involved in recursion using DP. Finally, we will cover the dynamic programming implementation of the Fibonacci series program. So, let's get started!
The topics covered in this presentation are:
1. Introduction
2. Real-Life Example of Dynamic Programming
3. Introduction to Dynamic Programming
4. Dynamic Programming Interpretation of Fibonacci Series Program
5. How Does Dynamic Programming Work?
What Is Dynamic Programming?
In computer science, something is said to be efficient if it is quick and uses minimal memory. By storing the solutions to subproblems, we can quickly look them up if the same problem arises again. Because there is no need to recompute the solution, this saves a significant amount of calculation time. But hold on! Efficiency comprises both time and space difficulty. But, why does it matter if we reduce the time required to solve the problem only to increase the space required? This is why it is critical to realize that the ultimate goal of Dynamic Programming is to obtain considerably quicker calculation time at the price of a minor increase in space utilized. Dynamic programming is defined as an algorithmic paradigm that solves a given complex problem by breaking it into several sub-problems and storing the results of those sub-problems to avoid the computation of the same sub-problem over and over again.
What is Programming?
Programming is an act of designing, developing, deploying an executlable software solution to the given user-defined problem.
Programming involves the following stages.
- Problem Statement
- Algorithms and Flowcharts
- Coding the program
- Debug the program.
- Documention
- Maintainence
Simplilearn’s Python Training Course is an all-inclusive program that will introduce you to the Python development language and expose you to the essentials of object-oriented programming, web development with Django and game development. Python has surpassed Java as the top language used to introduce U.S.
Learn more at: https://www.simplilearn.com/mobile-and-software-development/python-development-training
An Introduction to Functional Programming at the Jozi Java User GroupAndreas Pauley
Presented at the Jozi Java User Group in Sandton (Johannesburg) on July 28, 2014.
https://www.youtube.com/watch?v=PUqgCxurM0Y
http://www.meetup.com/Jozi-JUG/events/193527672/
The industry is moving towards Functional Programming.
Java 8 introduced lambdas and the JVM hosts a number of functional languages.
The .Net world has good support for FP in both C# and F#.
Apple has introduced Swift as their primary language for iOS development, a language heavily influenced by FP.
But what exactly is functional programming all about?
An Introduction to Functional Programming - DeveloperUG - 20140311Andreas Pauley
Functional Programming has received increased attention in recent years.
Some people claim that it provides important benefits to programming, but it seems somewhat inaccessible. You have to navigate through lots of academic-speak and look at examples that might only make sense to a professor in mathematics.
In this presentation I try to present some of the essential ideas behind functional programming, with simple examples first in Python and then in Haskell.
What do you need to know in order to enjoy this talk?
I have made some of the following assumptions about the kind of developer who will benefit from this talk:
1. You are a programmer using any programming language
2. You can read Python examples (it's WAY shorter on slides than C# or Java)
3. You are interested enough in improving your code that you are willing to challenge some common assumptions.
An introduction to the basics of reflection in the object-oriented programming language Java, part of a full lecture on Programming Paradigms at UCL university in Belgium, focussing on the programming languages Smalltalk, Ruby and Java, with reflection and meta programming as underlying theme.
Software Measurement: Lecture 1. Measures and MetricsProgrameter
Materials of the lecture on metrics and measures held by Programeter leadership during the Software Economics course at Tartu University: courses.cs.ut.ee/2010/se
A software agent controlling 2 robot arms in co-operating concurrent tasksRuleML
TeleoR is a major extension of Nilsson’s Teleo-Reactive (TR)
rule based robotic agent programming language. Programs comprise sequences of guarded action rules grouped into parameterised procedures.
The guards are deductive queries to a set of rapidly changing percept and other dynamic facts in the agent’s Belief Store. The actions are either tuples of primitive actions for external robotic resources, to be executed in parallel, or a single call to a TeleoR procedure, which can be a recursive call. The guards form a sub-goal tree routed at the guard of the first rule. When partially instantiated by the arguments of some call, this guard is the goal of the call.
TeleoR extends TR in being typed and higher order, with extra forms of rules that allow finer control over sub-goal achieving task behaviour.
Its Belief Store inference language is a higher order logic+function rule language, QuLog. QuLog also has action rules and primitive actions for updating the Belief Store and sending messages. The action of a TeleoR rule may be a combination of the action of a TR rule and a sequence of
QuLog actions. TeleoR’s most important extension of TR is the concept of task atomic procedures, some arguments of which belong to a special but application specific resource type. This allows the high level programming of multitasking agents using multiple robotic resources. When two or more tasks
need to use overlapping resources their use is alternated between task atomic calls in each task, in such a way that there is no interference, deadlock or task starvation.
This multi-task programming is illustrated by giving the essentials of a program for an agent controlling two robotic arms in multiple block tower assembly tasks. It has been used to control both a Python interactive graphical simulation and a Baxter robot building real block towers, in each case with help or hindrance from a human. The arms move in parallel whenever it can be done without risk of clashing.
Port Clearance Rules in PSOA RuleML: From Controlled-English Regulation to Ob...RuleML
The Decision Management (DM) Community Challenge of
March 2016 consisted of creating decision models from ten English Port Clearance Rules inspired by the International Ship and Port Facility Security
Code. Based on an analysis of the moderately controlled English
rules and current online solutions, we formalized the rules in PositionalSlotted,
Object-Applicative (PSOA) RuleML. This resulted in: (1) a
reordering, subgrouping, and explanation of the original rules on the
specialized decision-model expressiveness level of (deontically contextualized)
near-Datalog, non-recursive, near-deterministic, ground-queried,
and non-subpredicating rules; (2) an object-relational PSOA RuleML
rulebase which was complemented by facts to form a knowledge base queried in PSOATransRun for decision-making. Thus, the DM and logical formalizations get connected, which leads to generalized decision models with Hornlog, recursive, non-deterministic, non-ground-queried, and subpredicating rules.
More Related Content
Similar to Aggregates in Recursion: Issues and Solutions
Search and Optimization Strategies
Topics:
Definitions
Branch & Bound
Greedy
Local Search
Teaching material for the course of "Tecniche di Programmazione" at Politecnico di Torino in year 2012/2013. More information: http://bit.ly/tecn-progr
This presentation will introduce you to programming languages that support different programming paradigms and to give you the knowledge of basic concepts and techniques that will allow them to differentiate between various programming paradigms.
Incremental View Maintenance for openCypher QueriesGábor Szárnyas
Presented at the Fourth openCypher Implementers Meeting
Numerous graph use cases require continuous evaluation of queries over a constantly changing data set, e.g. fraud detection in financial systems, recommendations, and checking integrity constraints. For relational systems, incremental view maintenance has been researched for three decades, resulting in a wide body of literature. The property graph data model and the openCypher language, however, are recent developments, and therefore lack established techniques to perform efficient view maintenance. In this talk, we give an overview of the view maintenance problem for property graphs, discuss why it is particularly difficult and present an approach that tackles a meaningful subset of the language.
What Is Dynamic Programming? | Dynamic Programming Explained | Programming Fo...Simplilearn
This presentation on 'What Is Dynamic Programming?' will acquaint you with a clear understanding of how this programming paradigm works with the help of a real-life example. In this Dynamic Programming Tutorial, you will understand why recursion is not compatible and how you can solve the problems involved in recursion using DP. Finally, we will cover the dynamic programming implementation of the Fibonacci series program. So, let's get started!
The topics covered in this presentation are:
1. Introduction
2. Real-Life Example of Dynamic Programming
3. Introduction to Dynamic Programming
4. Dynamic Programming Interpretation of Fibonacci Series Program
5. How Does Dynamic Programming Work?
What Is Dynamic Programming?
In computer science, something is said to be efficient if it is quick and uses minimal memory. By storing the solutions to subproblems, we can quickly look them up if the same problem arises again. Because there is no need to recompute the solution, this saves a significant amount of calculation time. But hold on! Efficiency comprises both time and space difficulty. But, why does it matter if we reduce the time required to solve the problem only to increase the space required? This is why it is critical to realize that the ultimate goal of Dynamic Programming is to obtain considerably quicker calculation time at the price of a minor increase in space utilized. Dynamic programming is defined as an algorithmic paradigm that solves a given complex problem by breaking it into several sub-problems and storing the results of those sub-problems to avoid the computation of the same sub-problem over and over again.
What is Programming?
Programming is an act of designing, developing, deploying an executlable software solution to the given user-defined problem.
Programming involves the following stages.
- Problem Statement
- Algorithms and Flowcharts
- Coding the program
- Debug the program.
- Documention
- Maintainence
Simplilearn’s Python Training Course is an all-inclusive program that will introduce you to the Python development language and expose you to the essentials of object-oriented programming, web development with Django and game development. Python has surpassed Java as the top language used to introduce U.S.
Learn more at: https://www.simplilearn.com/mobile-and-software-development/python-development-training
An Introduction to Functional Programming at the Jozi Java User GroupAndreas Pauley
Presented at the Jozi Java User Group in Sandton (Johannesburg) on July 28, 2014.
https://www.youtube.com/watch?v=PUqgCxurM0Y
http://www.meetup.com/Jozi-JUG/events/193527672/
The industry is moving towards Functional Programming.
Java 8 introduced lambdas and the JVM hosts a number of functional languages.
The .Net world has good support for FP in both C# and F#.
Apple has introduced Swift as their primary language for iOS development, a language heavily influenced by FP.
But what exactly is functional programming all about?
An Introduction to Functional Programming - DeveloperUG - 20140311Andreas Pauley
Functional Programming has received increased attention in recent years.
Some people claim that it provides important benefits to programming, but it seems somewhat inaccessible. You have to navigate through lots of academic-speak and look at examples that might only make sense to a professor in mathematics.
In this presentation I try to present some of the essential ideas behind functional programming, with simple examples first in Python and then in Haskell.
What do you need to know in order to enjoy this talk?
I have made some of the following assumptions about the kind of developer who will benefit from this talk:
1. You are a programmer using any programming language
2. You can read Python examples (it's WAY shorter on slides than C# or Java)
3. You are interested enough in improving your code that you are willing to challenge some common assumptions.
An introduction to the basics of reflection in the object-oriented programming language Java, part of a full lecture on Programming Paradigms at UCL university in Belgium, focussing on the programming languages Smalltalk, Ruby and Java, with reflection and meta programming as underlying theme.
Software Measurement: Lecture 1. Measures and MetricsProgrameter
Materials of the lecture on metrics and measures held by Programeter leadership during the Software Economics course at Tartu University: courses.cs.ut.ee/2010/se
Similar to Aggregates in Recursion: Issues and Solutions (20)
A software agent controlling 2 robot arms in co-operating concurrent tasksRuleML
TeleoR is a major extension of Nilsson’s Teleo-Reactive (TR)
rule based robotic agent programming language. Programs comprise sequences of guarded action rules grouped into parameterised procedures.
The guards are deductive queries to a set of rapidly changing percept and other dynamic facts in the agent’s Belief Store. The actions are either tuples of primitive actions for external robotic resources, to be executed in parallel, or a single call to a TeleoR procedure, which can be a recursive call. The guards form a sub-goal tree routed at the guard of the first rule. When partially instantiated by the arguments of some call, this guard is the goal of the call.
TeleoR extends TR in being typed and higher order, with extra forms of rules that allow finer control over sub-goal achieving task behaviour.
Its Belief Store inference language is a higher order logic+function rule language, QuLog. QuLog also has action rules and primitive actions for updating the Belief Store and sending messages. The action of a TeleoR rule may be a combination of the action of a TR rule and a sequence of
QuLog actions. TeleoR’s most important extension of TR is the concept of task atomic procedures, some arguments of which belong to a special but application specific resource type. This allows the high level programming of multitasking agents using multiple robotic resources. When two or more tasks
need to use overlapping resources their use is alternated between task atomic calls in each task, in such a way that there is no interference, deadlock or task starvation.
This multi-task programming is illustrated by giving the essentials of a program for an agent controlling two robotic arms in multiple block tower assembly tasks. It has been used to control both a Python interactive graphical simulation and a Baxter robot building real block towers, in each case with help or hindrance from a human. The arms move in parallel whenever it can be done without risk of clashing.
Port Clearance Rules in PSOA RuleML: From Controlled-English Regulation to Ob...RuleML
The Decision Management (DM) Community Challenge of
March 2016 consisted of creating decision models from ten English Port Clearance Rules inspired by the International Ship and Port Facility Security
Code. Based on an analysis of the moderately controlled English
rules and current online solutions, we formalized the rules in PositionalSlotted,
Object-Applicative (PSOA) RuleML. This resulted in: (1) a
reordering, subgrouping, and explanation of the original rules on the
specialized decision-model expressiveness level of (deontically contextualized)
near-Datalog, non-recursive, near-deterministic, ground-queried,
and non-subpredicating rules; (2) an object-relational PSOA RuleML
rulebase which was complemented by facts to form a knowledge base queried in PSOATransRun for decision-making. Thus, the DM and logical formalizations get connected, which leads to generalized decision models with Hornlog, recursive, non-deterministic, non-ground-queried, and subpredicating rules.
Big data, with its four main characteristics (Volume, Velocity,
Variety, and Veracity) pose challenges to the gathering, management, analytics, and visualization of events. These very same four characteristics, however, also hold a great promise in unlocking the story behind data. In this talk, we focus on the observation that event creation is guided by processes. For example, GPS information, emitted by buses in an urban setting follow the bus scheduled route. Also, RTLS information about the whereabouts of patients and nurses in a hospital is guided by the predefined schedule of work. With this observation at hand, we thoroughly seek a method for mining, not the data, but rather the rules that guide data creation and show how, by knowing such rules, big data tasks become more efficient and more effective. In particular, we demonstrate how, by knowing the rules that govern event creation, we can detect complex events sooner and make use of historical data to predict future behaviors.
RuleML 2015: Ontology Reasoning using Rules in an eHealth ContextRuleML
Traditionally, nurse call systems in hospitals are rather simple:
patients have a button next to their bed to call a nurse. Which specific
nurse is called cannot be controlled, as there is no extra information
available. This is different for solutions based on semantic knowledge:
if the state of care givers (busy or free), their current position, and for
example their skills are known, a system can always choose the best
suitable nurse for a call. In this paper we describe such a semantic nurse
call system implemented using the EYE reasoner and Notation3 rules.
The system is able to perform OWL-RL reasoning. Additionally, we use
rules to implement complex decision trees. We compare our solution to
an implementation using OWL-DL, the Pellet reasoner, and SPARQL
queries. We show that our purely rule-based approach gives promising
results. Further improvements will lead to a mature product which will
significantly change the organization of modern hospitals.
RuleML 2015: Semantics of Notation3 Logic: A Solution for Implicit Quantifica...RuleML
Since the development of Notation3 Logic, several years have
passed in which the theory has been refined and used in practice by different reasoning engines such as cwm, FuXi or EYE. Nevertheless, a clear model-theoretic definition of its semantics is still missing. This leaves room for individual interpretations and renders it difficult to make clear
statements about its relation to other logics such as DL or FOL or even about such basic concepts as correctness. In this paper we address one of the main open challenges: the formalization of implicit quantification.
We point out how the interpretation of implicit quantifiers differs in two of the above mentioned reasoning engines and how the specification, proposed in the W3C team submission, could be formalized. Our formalization is then put into context by integrating it into a model-theoretic definition of the whole language. We finish our contribution by arguing why universal quantification should be handled differently than currently
prescribed.
Challenge@RuleML2015 Developing Situation-Aware Applications for Disaster Man...RuleML
In order to enhance interoperability and productivity in the develop-ment of situation-aware applications for disaster management, proper mecha-nisms and guidelines are required. They must address the lack of semantics in modelling emergency situations. In addition, the ever-changing and unpredicta-ble nature of disaster scenarios present challenges for information processing and collaboration. This paper proposes a framework that combines the follow-ing elements: (i) a foundational ontology for temporal conceptualization; (ii) well-founded specifications of structural and behavioral models; (iii) a CEP en-gine based on a distributed rule-based platform for situation management; (iv) a model-driven approach. We illustrate the operation of the framework with a scenario for monitoring tuberculosis epidemy.
Rule Generalization Strategies in Incremental Learning of Disjunctive ConceptsRuleML
Symbolic Machine Learning systems and applications, especially when applied to real-world domains, must face the problem of concepts that cannot be captured by a single definition, but require several alternate definitions, each of which covers part of the full concept extension. This problem is particularly relevant for incremental systems, where progressive covering approaches are not applicable, and the learning and refinement of the various definitions is interleaved during the learning phase. In these systems, not only the learned model depends on the order in which the examples are provided, but it also depends on
the choice of the specific definition to be refined. This paper proposes different strategies for determining the order in which the alternate definitions of a concept should be considered in a generalization step, and
evaluates their performance on a real-world domain dataset.
RuleML 2015 Constraint Handling Rules - What Else?RuleML
Constraint Handling Rules (CHR) is both a versatile theoretical formalism based on logic and an efficient practical high-level programming language based on rules and constraints.
Procedural knowledge is often expressed by if-then rules, events and actions are related by reaction rules, change is expressed by update rules. Algorithms are often specified using inference rules, rewrite rules, transition rules, sequents, proof rules, or logical axioms. All these kinds of rules can be directly written in CHR. The clean logical semantics of CHR facilitates non-trivial program analysis and transformation. About a dozen implementations of CHR exist in Prolog, Haskell, Java, Javascript and C. Some of them allow to apply millions of rules per second. CHR is also available as WebCHR for online experimentation with more than 40 example programs. More than 200 academic and industrial projects worldwide use CHR, and about 2000 research papers reference it.
RuleML2015 The Herbrand Manifesto - Thinking Inside the Box RuleML
The traditional semantics for First Order Logic (sometimes called Tarskian semantics) is based on the notion of interpretations of constants. Herbrand semantics is an alternative semantics based directly on truth assignments for ground sentences rather than interpretations of constants. Herbrand semantics is simpler and more intuitive than Tarskian semantics; and, consequently, it is easier to teach and learn. Moreover, it is more expressive. For example, while it is not possible to finitely axiomatize integer arithmetic with Tarskian semantics, this can be done easily with Herbrand Semantics. The downside is a loss of some common logical properties, such as compactness and completeness. However, there is no loss of inferential power. Anything that can be proved according to Tarskian semantics can also be proved according to Herbrand semantics. In this presentation, we define Herbrand semantics; we look at the implications for research on logic and rules systems and automated reasoning; and and we assess the potential for popularizing logic.
Industry@RuleML2015: Norwegian State of Estate A Reporting Service for the St...RuleML
Data distribution
•Public and private
•Data complexity
•Rich in attributes and location based
•Time dimension
•Example of data model from the Norwegian Mapping Authority
Datalog+-Track Introduction & Reasoning on UML Class Diagrams via Datalog+-RuleML
UML class diagrams (UCDs) are a widely adopted formalism
for modeling the intensional structure of a software system. Although
UCDs are typically guiding the implementation of a system, it is common
in practice that developers need to recover the class diagram from an
implemented system. This process is known as reverse engineering. A
fundamental property of reverse engineered (or simply re-engineered)
UCDs is consistency, showing that the system is realizable in practice.
In this work, we investigate the consistency of re-engineered UCDs, and
we show is pspace-complete. The upper bound is obtained by exploiting
algorithmic techniques developed for conjunctive query answering under
guarded Datalog+/-, that is, a key member of the Datalog+/- family
of KR languages, while the lower bound is obtained by simulating the
behavior of a polynomial space Turing machine.
RuleML2015: Binary Frontier-guarded ASP with Function SymbolsRuleML
It has been acknowledged that emerging Web applications
require features that are not available in standard rule languages like
Datalog or Answer Set Programming (ASP), e.g., they are not powerful
enough to deal with anonymous values (objects that are not explicitly
mentioned in the data but whose existence is implied by the background
knowledge). In this paper, we introduce a new rule language based on
ASP extended with function symbols, which can be used to reason about
anonymous values. In particular, we define binary frontier-guarded programs
(BFG programs) that allow for disjunction, function symbols, and
negation under the stable model semantics. In order to ensure decidability,
BFG programs are syntactically restricted by allowing at most
binary predicates and by requiring rules to be frontier-guarded. BFG programs
are expressive enough to simulate ontologies expressed in popular
Description Logics (DLs), capture their recent non-monotonic extensions,
and can simulate conjunctive query answering over many standard DLs.
We provide an elegant automata-based algorithm to reason in BFG programs,
which yields a 3ExpTime upper bound for reasoning tasks like
deciding consistency or cautious entailment. Due to existing results, these
problems are known to be 2ExpTime-hard.
RuleML2015: API4KP Metamodel: A Meta-API for Heterogeneous Knowledge PlatformsRuleML
API4KP (API for Knowledge Platforms) is a standard
development effort that targets the basic administration services as
well as the retrieval, modification and processing of expressions in
machine-readable languages, including but not limited to knowledge
representation and reasoning (KRR) languages, within heterogeneous
(multi-language, multi-nature) knowledge platforms. KRR languages of
concern in this paper include but are not limited to RDF(S), OWL,
RuleML and Common Logic, and the knowledge platforms may support
one or several of these. Additional languages are integrated using mappings
into KRR languages. A general notion of structure for knowledge
sources is developed using monads. The presented API4KP metamodel,
in the form of an OWL ontology, provides the foundation of an abstract
syntax for communications about knowledge sources and environments,
including a classification of knowledge source by mutability, structure,
and an abstraction hierarchy as well as the use of performatives (inform,
query, ...), languages, logics, dialects, formats and lineage. Finally, the
metamodel provides a classification of operations on knowledge sources
and environments which may be used for requests (message-passing).
RuleML2015: Rule-Based Exploration of Structured Data in the BrowserRuleML
We present Dexter, a browser-based, domain-independent
structured-data explorer for users. Dexter enables users to explore data
from multiple local and Web-accessible heterogeneous data sources such
as files, Web pages, APIs and databases in the form of tables. Dexter’s
users can also compute tables from existing ones as well as validate
the tables (base or computed) through declarative rules. Dexter enables
users to perform ad hoc queries over their tables with higher expressivity
than that is supported by the underlying data sources. Dexter evaluates
a user’s query on the client side while evaluating sub-queries on remote
sources whenever possible. Dexter also allows users to visualize and share
tables, and export (e.g., in JSON, plain XML, and RuleML) tables along
with their computation rules. Dexter has been tested for a variety of data
sets from domains such as government and apparel manufacturing. Dexter
is available online at http://dexter.stanford.edu.
RuleML2015: Ontology-Based Multidimensional Contexts with Applications to Qua...RuleML
Data quality assessment and data cleaning are context
dependent activities. Starting from this observation, in previous work
a context model for the assessment of the quality of a database was
proposed. A context takes the form of a possibly virtual database or
a data integration system into which the database under assessment is
mapped, for additional analysis, processing, and quality data extraction.
In this work, we extend contexts with dimensions, and by doing so, multidimensional
data quality assessment becomes possible. At the core of
multidimensional contexts we find ontologies written as Datalog
±
programs
with provably good properties in terms of query answering. We
use this language to represent dimension hierarchies, dimensional constraints,
dimensional rules, and specifying quality data. Query answering
relies on and triggers dimensional navigation, and becomes an important
tool for the extraction of quality data.
RuleML2015: Compact representation of conditional probability for rule-based...RuleML
Context-aware systems gained huge popularity in recent
years due to rapid evolution of personal mobile devices. Equipped with
variety of sensors, such devices are sources of a lot of valuable information
that allows the system to act in an intelligent way. However, the
certainty and presence of this information may depend on many factors
like measurement accuracy or sensor availability. Such a dynamic
nature of information may cause the system not to work properly or
not to work at all. To allow for robustness of the context-aware system
an uncertainty handling mechanism should be provided with it. Several
approaches were developed to solve uncertainty in context knowledge
bases, including probabilistic reasoning, fuzzy logic, or certainty
factors. In this paper, we present a representation method that combines
strengths of rules based on the attributive logic and Bayesian networks.
Such a combination allows efficiently encode conditional probability distribution
of random variables into a reasoning structure called XTT2.
This provides a method for building hybrid context-aware systems that
allows for robust inference in uncertain knowledge bases.
RuleML2015: Learning Characteristic Rules in Geographic Information SystemsRuleML
We provide a general framework for learning characterization
rules of a set of objects in Geographic Information Systems (GIS) relying
on the definition of distance quantified paths. Such expressions specify
how to navigate between the different layers of the GIS starting from
the target set of objects to characterize. We have defined a generality
relation between quantified paths and proved that it is monotonous with
respect to the notion of coverage, thus allowing to develop an interactive
and effective algorithm to explore the search space of possible rules. We
describe GISMiner, an interactive system that we have developed based
on our framework. Finally, we present our experimental results from a
real GIS about mineral exploration.
RuleML2015: Using Substitutive Itemset Mining Framework for Finding Synonymou...RuleML
Over the last two decades frequent itemset and association
rule mining has attracted huge attention from the scientific community
which resulted in numerous publications, models, algorithms, and optimizations
of basic frameworks. In this paper we introduce an extension
of the frequent itemset framework, called substitutive itemsets. Substitutive
itemsets allow to discover equivalences between items, i.e., they
represent pairs of items that can be used interchangeably in many contexts.
In the paper we present basic notions pertaining to substitutive
itemsets, describe the implementation of the proposed method available
as a RapidMiner plugin, and illustrate the use of the framework for mining
substitutive object properties in the Linked Data.
Remote Sensing and Computational, Evolutionary, Supercomputing, and Intellige...University of Maribor
Slides from talk:
Aleš Zamuda: Remote Sensing and Computational, Evolutionary, Supercomputing, and Intelligent Systems.
11th International Conference on Electrical, Electronics and Computer Engineering (IcETRAN), Niš, 3-6 June 2024
Inter-Society Networking Panel GRSS/MTT-S/CIS Panel Session: Promoting Connection and Cooperation
https://www.etran.rs/2024/en/home-english/
DERIVATION OF MODIFIED BERNOULLI EQUATION WITH VISCOUS EFFECTS AND TERMINAL V...Wasswaderrick3
In this book, we use conservation of energy techniques on a fluid element to derive the Modified Bernoulli equation of flow with viscous or friction effects. We derive the general equation of flow/ velocity and then from this we derive the Pouiselle flow equation, the transition flow equation and the turbulent flow equation. In the situations where there are no viscous effects , the equation reduces to the Bernoulli equation. From experimental results, we are able to include other terms in the Bernoulli equation. We also look at cases where pressure gradients exist. We use the Modified Bernoulli equation to derive equations of flow rate for pipes of different cross sectional areas connected together. We also extend our techniques of energy conservation to a sphere falling in a viscous medium under the effect of gravity. We demonstrate Stokes equation of terminal velocity and turbulent flow equation. We look at a way of calculating the time taken for a body to fall in a viscous medium. We also look at the general equation of terminal velocity.
What is greenhouse gasses and how many gasses are there to affect the Earth.moosaasad1975
What are greenhouse gasses how they affect the earth and its environment what is the future of the environment and earth how the weather and the climate effects.
ISI 2024: Application Form (Extended), Exam Date (Out), EligibilitySciAstra
The Indian Statistical Institute (ISI) has extended its application deadline for 2024 admissions to April 2. Known for its excellence in statistics and related fields, ISI offers a range of programs from Bachelor's to Junior Research Fellowships. The admission test is scheduled for May 12, 2024. Eligibility varies by program, generally requiring a background in Mathematics and English for undergraduate courses and specific degrees for postgraduate and research positions. Application fees are ₹1500 for male general category applicants and ₹1000 for females. Applications are open to Indian and OCI candidates.
Phenomics assisted breeding in crop improvementIshaGoswami9
As the population is increasing and will reach about 9 billion upto 2050. Also due to climate change, it is difficult to meet the food requirement of such a large population. Facing the challenges presented by resource shortages, climate
change, and increasing global population, crop yield and quality need to be improved in a sustainable way over the coming decades. Genetic improvement by breeding is the best way to increase crop productivity. With the rapid progression of functional
genomics, an increasing number of crop genomes have been sequenced and dozens of genes influencing key agronomic traits have been identified. However, current genome sequence information has not been adequately exploited for understanding
the complex characteristics of multiple gene, owing to a lack of crop phenotypic data. Efficient, automatic, and accurate technologies and platforms that can capture phenotypic data that can
be linked to genomics information for crop improvement at all growth stages have become as important as genotyping. Thus,
high-throughput phenotyping has become the major bottleneck restricting crop breeding. Plant phenomics has been defined as the high-throughput, accurate acquisition and analysis of multi-dimensional phenotypes
during crop growing stages at the organism level, including the cell, tissue, organ, individual plant, plot, and field levels. With the rapid development of novel sensors, imaging technology,
and analysis methods, numerous infrastructure platforms have been developed for phenotyping.
Observation of Io’s Resurfacing via Plume Deposition Using Ground-based Adapt...Sérgio Sacani
Since volcanic activity was first discovered on Io from Voyager images in 1979, changes
on Io’s surface have been monitored from both spacecraft and ground-based telescopes.
Here, we present the highest spatial resolution images of Io ever obtained from a groundbased telescope. These images, acquired by the SHARK-VIS instrument on the Large
Binocular Telescope, show evidence of a major resurfacing event on Io’s trailing hemisphere. When compared to the most recent spacecraft images, the SHARK-VIS images
show that a plume deposit from a powerful eruption at Pillan Patera has covered part
of the long-lived Pele plume deposit. Although this type of resurfacing event may be common on Io, few have been detected due to the rarity of spacecraft visits and the previously low spatial resolution available from Earth-based telescopes. The SHARK-VIS instrument ushers in a new era of high resolution imaging of Io’s surface using adaptive
optics at visible wavelengths.
Professional air quality monitoring systems provide immediate, on-site data for analysis, compliance, and decision-making.
Monitor common gases, weather parameters, particulates.
Deep Behavioral Phenotyping in Systems Neuroscience for Functional Atlasing a...Ana Luísa Pinho
Functional Magnetic Resonance Imaging (fMRI) provides means to characterize brain activations in response to behavior. However, cognitive neuroscience has been limited to group-level effects referring to the performance of specific tasks. To obtain the functional profile of elementary cognitive mechanisms, the combination of brain responses to many tasks is required. Yet, to date, both structural atlases and parcellation-based activations do not fully account for cognitive function and still present several limitations. Further, they do not adapt overall to individual characteristics. In this talk, I will give an account of deep-behavioral phenotyping strategies, namely data-driven methods in large task-fMRI datasets, to optimize functional brain-data collection and improve inference of effects-of-interest related to mental processes. Key to this approach is the employment of fast multi-functional paradigms rich on features that can be well parametrized and, consequently, facilitate the creation of psycho-physiological constructs to be modelled with imaging data. Particular emphasis will be given to music stimuli when studying high-order cognitive mechanisms, due to their ecological nature and quality to enable complex behavior compounded by discrete entities. I will also discuss how deep-behavioral phenotyping and individualized models applied to neuroimaging data can better account for the subject-specific organization of domain-general cognitive systems in the human brain. Finally, the accumulation of functional brain signatures brings the possibility to clarify relationships among tasks and create a univocal link between brain systems and mental functions through: (1) the development of ontologies proposing an organization of cognitive processes; and (2) brain-network taxonomies describing functional specialization. To this end, tools to improve commensurability in cognitive science are necessary, such as public repositories, ontology-based platforms and automated meta-analysis tools. I will thus discuss some brain-atlasing resources currently under development, and their applicability in cognitive as well as clinical neuroscience.
The use of Nauplii and metanauplii artemia in aquaculture (brine shrimp).pptxMAGOTI ERNEST
Although Artemia has been known to man for centuries, its use as a food for the culture of larval organisms apparently began only in the 1930s, when several investigators found that it made an excellent food for newly hatched fish larvae (Litvinenko et al., 2023). As aquaculture developed in the 1960s and ‘70s, the use of Artemia also became more widespread, due both to its convenience and to its nutritional value for larval organisms (Arenas-Pardo et al., 2024). The fact that Artemia dormant cysts can be stored for long periods in cans, and then used as an off-the-shelf food requiring only 24 h of incubation makes them the most convenient, least labor-intensive, live food available for aquaculture (Sorgeloos & Roubach, 2021). The nutritional value of Artemia, especially for marine organisms, is not constant, but varies both geographically and temporally. During the last decade, however, both the causes of Artemia nutritional variability and methods to improve poorquality Artemia have been identified (Loufi et al., 2024).
Brine shrimp (Artemia spp.) are used in marine aquaculture worldwide. Annually, more than 2,000 metric tons of dry cysts are used for cultivation of fish, crustacean, and shellfish larva. Brine shrimp are important to aquaculture because newly hatched brine shrimp nauplii (larvae) provide a food source for many fish fry (Mozanzadeh et al., 2021). Culture and harvesting of brine shrimp eggs represents another aspect of the aquaculture industry. Nauplii and metanauplii of Artemia, commonly known as brine shrimp, play a crucial role in aquaculture due to their nutritional value and suitability as live feed for many aquatic species, particularly in larval stages (Sorgeloos & Roubach, 2021).
Richard's aventures in two entangled wonderlandsRichard Gill
Since the loophole-free Bell experiments of 2020 and the Nobel prizes in physics of 2022, critics of Bell's work have retreated to the fortress of super-determinism. Now, super-determinism is a derogatory word - it just means "determinism". Palmer, Hance and Hossenfelder argue that quantum mechanics and determinism are not incompatible, using a sophisticated mathematical construction based on a subtle thinning of allowed states and measurements in quantum mechanics, such that what is left appears to make Bell's argument fail, without altering the empirical predictions of quantum mechanics. I think however that it is a smoke screen, and the slogan "lost in math" comes to my mind. I will discuss some other recent disproofs of Bell's theorem using the language of causality based on causal graphs. Causal thinking is also central to law and justice. I will mention surprising connections to my work on serial killer nurse cases, in particular the Dutch case of Lucia de Berk and the current UK case of Lucy Letby.
hematic appreciation test is a psychological assessment tool used to measure an individual's appreciation and understanding of specific themes or topics. This test helps to evaluate an individual's ability to connect different ideas and concepts within a given theme, as well as their overall comprehension and interpretation skills. The results of the test can provide valuable insights into an individual's cognitive abilities, creativity, and critical thinking skills
ANAMOLOUS SECONDARY GROWTH IN DICOT ROOTS.pptxRASHMI M G
Abnormal or anomalous secondary growth in plants. It defines secondary growth as an increase in plant girth due to vascular cambium or cork cambium. Anomalous secondary growth does not follow the normal pattern of a single vascular cambium producing xylem internally and phloem externally.
1. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Aggregates in Recursion: Issues and
Solutions
Wolfgang Faber
Alpen-Adria-Universität Klagenfurt
RuleML Webinar, 2018-05-25
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
2. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Outline
1 Motivation
2 Basics: Answer Set Programming and Aggregates
3 Semantics
Stratified Aggregates
Unstratified Aggregates
4 Properties
Coincidence Results
Complexity Results
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
3. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Motivation: Aggregates
Aggregates facilitate problem representation
Standard in database query languages
For example:
SELECT company.name FROM company,employee
WHERE company.id = employee.cid AND
COUNT(employee.id) < 10
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
4. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Motivation: Aggregates and Logic Programming
In this talk: Combination of Logic Programming and
Aggregates
For example:
SELECT company.name FROM company,employee
WHERE company.id = employee.cid AND
COUNT(employee.id) < 10
using Logic Programming (here ASP/Datalog):
result(N) :- company(N, Y), #count{X : employee(X, Y)} < 10.
Does this look innocent?
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
5. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Recursion
A main feature of Logic Programming is recursion
Example:
tc(A, B) :- p(A, B).
tc(A, B) :- p(A, X), tc(X, B).
defines the transitive closure of p
Supported also in SQL
Recent (since SQL-99)
Not particularly well-known
Common Table Expressions (CTE)
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
6. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Recursion and Aggregates
Combination of recursion and aggregates?
Explicitly forbidden in SQL!
Meaning of
p(a) :- #count{X : p(X)} > 0.
Meaning of
p(a) :- #count{X : p(X)} < 1.
Meaning of
p(1) :- #avg{X : p(X)}! = 1.
p(−1) :- #avg{X : p(X)}! = 1.
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
7. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
ASP Semantics
Herbrand interpretations
Reduct for interpretation I:
1 Delete rules whose negative body is true in I.
2 Delete negative body from all other rules.
Interpretations I which are minimal models of the reduct for
I are answer sets.
[Gelfond, Lifschitz 1988] (nondisjunctive)
[Przymusinski 1991] (disjunctive)
[Gelfond, Lifschitz 1991] (disjunctive, 2 kinds of negation)
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
8. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
ASP Semantics
Herbrand interpretations
Reduct for interpretation I:
1 Delete rules whose negative body is true in I.
2 Delete negative body from all other rules.
Interpretations I which are minimal models of the reduct for
I are answer sets.
[Gelfond, Lifschitz 1988] (nondisjunctive)
[Przymusinski 1991] (disjunctive)
[Gelfond, Lifschitz 1991] (disjunctive, 2 kinds of negation)
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
9. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Aggregates
Aggregate Functions: Functions over ground term
(multi)sets
(Multi)sets specified as {A, B : Conj} or { c, d : Conj , . . .}
Evaluate Conj w.r.t. an interpretation
Aggregate Atoms: Aggregate Function plus comparison
Important: Aggregate atoms depend on truth values of a set of
standard atoms!
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
10. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Aggregates
Aggregate Functions: Functions over ground term
(multi)sets
(Multi)sets specified as {A, B : Conj} or { c, d : Conj , . . .}
Evaluate Conj w.r.t. an interpretation
Aggregate Atoms: Aggregate Function plus comparison
Important: Aggregate atoms depend on truth values of a set of
standard atoms!
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
11. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Aggregates
Aggregate Functions: Functions over ground term
(multi)sets
(Multi)sets specified as {A, B : Conj} or { c, d : Conj , . . .}
Evaluate Conj w.r.t. an interpretation
Aggregate Atoms: Aggregate Function plus comparison
Important: Aggregate atoms depend on truth values of a set of
standard atoms!
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
12. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Aggregates
Aggregate Functions: Functions over ground term
(multi)sets
(Multi)sets specified as {A, B : Conj} or { c, d : Conj , . . .}
Evaluate Conj w.r.t. an interpretation
Aggregate Atoms: Aggregate Function plus comparison
Important: Aggregate atoms depend on truth values of a set of
standard atoms!
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
13. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Outline
1 Motivation
2 Basics: Answer Set Programming and Aggregates
3 Semantics
Stratified Aggregates
Unstratified Aggregates
4 Properties
Coincidence Results
Complexity Results
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
14. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Aggregate Stratification
Definition
A program P is stratified on an aggregate atom A if there exists
a level mapping || || from its predicates to ordinals, such that for
each rule and for each of its head atoms a the following holds:
1 For each predicate b of standard body literals: ||b|| ≤ ||a||,
2 for each predicate b inside an aggregate body atom:
||b|| < ||a||, and
3 for each predicate b in the head: ||b|| = ||a||.
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
15. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Aggregate Stratification
Note: Stratification is relative to a program
Unstratified aggregate atoms occur recursively
Example
a :- #count{ t : b } > 0.
is stratified on the aggregate atom.
a :- #count{ t : b } > 0.
b :- a.
is not stratified on the aggregate atom.
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
16. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Answer Sets for Aggregate-stratified Programs
Basic Idea: Treat aggregate atoms like negative literals
Reduct:
1 Delete rules containing unsatisfied aggregates and
negative literals
2 Delete aggregates and negative literals from all other rules
[Kemp, Stuckey 1991], [Gelfond 2002],
[Dell’Armi, F., Ielpa, Leone, Pfeifer 2003]
Many programs are aggregate stratified
Use of aggregates often yields computational advantages
But: Not all programs are aggregate stratified
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
17. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Answer Sets for Aggregate-stratified Programs
Basic Idea: Treat aggregate atoms like negative literals
Reduct:
1 Delete rules containing unsatisfied aggregates and
negative literals
2 Delete aggregates and negative literals from all other rules
[Kemp, Stuckey 1991], [Gelfond 2002],
[Dell’Armi, F., Ielpa, Leone, Pfeifer 2003]
Many programs are aggregate stratified
Use of aggregates often yields computational advantages
But: Not all programs are aggregate stratified
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
18. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Answer Sets for Aggregate-stratified Programs
Basic Idea: Treat aggregate atoms like negative literals
Reduct:
1 Delete rules containing unsatisfied aggregates and
negative literals
2 Delete aggregates and negative literals from all other rules
[Kemp, Stuckey 1991], [Gelfond 2002],
[Dell’Armi, F., Ielpa, Leone, Pfeifer 2003]
Many programs are aggregate stratified
Use of aggregates often yields computational advantages
But: Not all programs are aggregate stratified
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
19. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Outline
1 Motivation
2 Basics: Answer Set Programming and Aggregates
3 Semantics
Stratified Aggregates
Unstratified Aggregates
4 Properties
Coincidence Results
Complexity Results
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
20. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Unstratification
What happens when we consider unstratified aggregates?
Can we just keep the simple semantic definition?
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
21. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Company Control
Input: Set of companies and shares companies hold of other
companies.
Output: Companies controlled (direct or indirect shares > 50%)
by other companies
Encoding from the literature:
controlsStk(C1, C1, C2, P) :- ownsStk(C1, C2, P).
controlsStk(C1, C2, C3, P) :- controls(C1, C2), ownsStk(C2, C3, P).
controls(C1, C3) :- company(C1), company(C3),
#sum{P, C2 : controlsStk(C1, C2, C3, P)} > 50.
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
22. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Company Control, Instance 1
Example (Company Control, Instance 1)
30%
40%
60%
35%
15%
a
c
d
b
{controlsStk(a,a,b,60),
controlsStk(a,a,c,30),
controlsStk(a,a,d,15),
controlsStk(b,b,d,40),
controlsStk(c,c,d,35),
controlsStk(a,b,d,40),
controls(a,b),
controls(a,d)}
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
23. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Company Control, Instance 1
Example (Company Control, Instance 1)
30%
40%
60%
35%
15%
a
c
d
b
{controlsStk(a,a,b,60),
controlsStk(a,a,c,30),
controlsStk(a,a,d,15),
controlsStk(b,b,d,40),
controlsStk(c,c,d,35),
controlsStk(a,b,d,40),
controls(a,b),
controls(a,d)}
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
24. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Company Control, Instance 2
Example (Company Control, Instance 2)
a
cb
40% 40%
20%
20%
{controlsStk(a,a,b,40),
controlsStk(a,a,c,40),
controlsStk(b,b,c,20),
controlsStk(c,c,b,20)}
But also:
{controlsStk(a,b,c,20),
controlsStk(a,c,b,20),
controls(a,b),
controls(a,c)}
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
25. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Company Control, Instance 2
Example (Company Control, Instance 2)
a
cb
40% 40%
20%
20%
{controlsStk(a,a,b,40),
controlsStk(a,a,c,40),
controlsStk(b,b,c,20),
controlsStk(c,c,b,20)}
But also:
{controlsStk(a,b,c,20),
controlsStk(a,c,b,20),
controls(a,b),
controls(a,c)}
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
26. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Company Control, Instance 2
Example (Company Control, Instance 2)
a
cb
40% 40%
20%
20%
{controlsStk(a,a,b,40),
controlsStk(a,a,c,40),
controlsStk(b,b,c,20),
controlsStk(c,c,b,20)}
But also:
{controlsStk(a,b,c,20),
controlsStk(a,c,b,20),
controls(a,b),
controls(a,c)}
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
27. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Essence
Example
a :- #count{ t : a } < 1.
No answer sets.
a :- #count{ t : a } > 0.
Answer sets: ∅, {a}?
#count{ t : a } < 1 behaves like not a
#count{ t : a } > 0 behaves like a
⇒ aggregates should not be treated like negative literals, but
also not like positive literals
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
28. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Essence
Example
a :- #count{ t : a } < 1.
No answer sets.
a :- #count{ t : a } > 0.
Answer sets: ∅, {a}?
#count{ t : a } < 1 behaves like not a
#count{ t : a } > 0 behaves like a
⇒ aggregates should not be treated like negative literals, but
also not like positive literals
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
29. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Monotonicity and Antimonotonicity
Monotone Literals:
truth for interpretation I implies truth for all J ⊇ I
Antimonotone Literals:
truth for interpretation J implies truth for all I ⊆ J
Nonmonotone Literals:
neither monotone nor antimonotone
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
30. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Monotonicity: Examples
#count{. . .} ≥ 1 is monotone
#count{. . .} < 1 is antimonotone
#avg{. . .} < 3 is nonmonotone
Positive standard literals are monotone
Negative standard literals are antimonotone
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
31. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
FLP Semantics: Novel Reduct Definition
Definition of reduct according to [F.,Leone,Pfeifer 2004, F.,
Leone, Pfeifer 2011]:
Delete rules with a false body literal.
That’s it!
Answer Set: Subset-minimal model of the reduct
Theorem
For aggregate-free programs, answer sets under this definition
coincide with the ones defined in [Gelfond, Lifschitz 1991].
(Mostly) equivalent semantics defined in [Ferraris 2005],
[Ferraris 2011].
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
32. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
FLP Semantics: Novel Reduct Definition
Definition of reduct according to [F.,Leone,Pfeifer 2004, F.,
Leone, Pfeifer 2011]:
Delete rules with a false body literal.
That’s it!
Answer Set: Subset-minimal model of the reduct
Theorem
For aggregate-free programs, answer sets under this definition
coincide with the ones defined in [Gelfond, Lifschitz 1991].
(Mostly) equivalent semantics defined in [Ferraris 2005],
[Ferraris 2011].
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
33. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
FLP Semantics: Novel Reduct Definition
Definition of reduct according to [F.,Leone,Pfeifer 2004, F.,
Leone, Pfeifer 2011]:
Delete rules with a false body literal.
That’s it!
Answer Set: Subset-minimal model of the reduct
Theorem
For aggregate-free programs, answer sets under this definition
coincide with the ones defined in [Gelfond, Lifschitz 1991].
(Mostly) equivalent semantics defined in [Ferraris 2005],
[Ferraris 2011].
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
34. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Company Control, Instance 1
Example (Company Control, Instance 1)
30%
40%
60%
35%
15%
a
c
d
b
{controlsStk(a,a,b,60),
controlsStk(a,a,c,30),
controlsStk(a,a,d,15),
controlsStk(b,b,d,40),
controlsStk(c,c,d,35),
controlsStk(a,b,d,40),
controls(a,b),
controls(a,d)}
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
35. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Company Control, Instance 1
Example (Company Control, Instance 1)
30%
40%
60%
35%
15%
a
c
d
b
{controlsStk(a,a,b,60),
controlsStk(a,a,c,30),
controlsStk(a,a,d,15),
controlsStk(b,b,d,40),
controlsStk(c,c,d,35),
controlsStk(a,b,d,40),
controls(a,b),
controls(a,d)}
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
36. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Company Control, Instance 2
Example (Company Control, Instance 2)
a
cb
40% 40%
20%
20%
{controlsStk(a,a,b,40),
controlsStk(a,a,c,40),
controlsStk(b,b,c,20),
controlsStk(c,c,b,20)}
Only this answer set.
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
37. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Company Control, Instance 2
Example (Company Control, Instance 2)
a
cb
40% 40%
20%
20%
{controlsStk(a,a,b,40),
controlsStk(a,a,c,40),
controlsStk(b,b,c,20),
controlsStk(c,c,b,20)}
Only this answer set.
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
38. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Small examples
Example
a :- #count{ t : a } < 1.
No answer sets.
a :- #count{ t : a } > 0.
Answer sets: only ∅
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
39. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
PSP Semantics
Alternative semantics for unstratified aggregates:
[Pelov 2004], [Son, Pontelli 2007], [Shen, Wang 2012]
Definitions use different operator-based techniques
Evaluate aggregates for a pair of interpretations
(I, J) |= A iff K |= A for all I ⊆ K ⊆ J.
PSP answer sets are those I that are fixpoints of KI
Π ⇑ ∅
Operator KI
Π(X) collects heads of rules for which
(X, I) |= A for all body atoms
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
40. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Stratified Aggregates
Unstratified Aggregates
Small examples: PSP
Example
a :- #count{ t : a } < 1.
No answer sets.
K∅
Π(∅) = {a}
K∅
Π({a}) = {a}
K
{a}
Π (∅) = ∅
a :- #count{ t : a } > 0.
Answer sets: only ∅
K∅
Π(∅) = ∅
K
{a}
Π (∅) = ∅
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
41. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Outline
1 Motivation
2 Basics: Answer Set Programming and Aggregates
3 Semantics
Stratified Aggregates
Unstratified Aggregates
4 Properties
Coincidence Results
Complexity Results
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
42. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
FLP and PSP
Small examples could suggest that they coincide.
But this is not true in general.
Example
p(1) :- #avg{X : p(X)} ≥ 0.
p(1) :- p(−1).
p(−1) :- p(1).
FLP answer sets: {p(1), p(−1)}
PSP answer sets: none
In general: each PSP answer set is also FLP, but not
necessarily vice versa.
Classes on which the semantics coincide?
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
43. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Aggregate-stratified Programs
Easy observation:
Theorem
FLP and PSP semantics coincide on aggregate-stratified
programs.
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
44. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Monotone, antimonotone, convex
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
{a, b, c, d}
{a, b, c} {a, b, d} {a, c, d} {b, c, d}
{a, b} {a, c} {a, d} {b, c} {b, d} {c, d}
{a} {b} {c} {d}
∅
1 ≤ #count{a, b, c, d}
S is monotone if
I |= S ∧ J |= S =⇒
K |= S ∀K ∈ ↑I ∩ ↓J
45. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Monotone, antimonotone, convex
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
{a, b, c, d}
{a, b, c} {a, b, d} {a, c, d} {b, c, d}
{a, b} {a, c} {a, d} {b, c} {b, d} {c, d}
{a} {b} {c} {d}
∅
1 ≤ #count{a, b, c, d}
S is monotone if
I |= S ∧ J |= S =⇒
K |= S ∀K ∈ ↑I ∩ ↓J
46. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Monotone, antimonotone, convex
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
{a, b, c, d}
{a, b, c} {a, b, d} {a, c, d} {b, c, d}
{a, b} {a, c} {a, d} {b, c} {b, d} {c, d}
{a} {b} {c} {d}
∅
#count{a, b, c, d} ≤ 3
S is antimonotone if
I |= S ∧ J |= S =⇒
K |= S ∀K ∈ ↑I ∩ ↓J
47. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Monotone, antimonotone, convex
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
{a, b, c, d}
{a, b, c} {a, b, d} {a, c, d} {b, c, d}
{a, b} {a, c} {a, d} {b, c} {b, d} {c, d}
{a} {b} {c} {d}
∅
#count{a, b, c, d} ≤ 3
S is antimonotone if
I |= S ∧ J |= S =⇒
K |= S ∀K ∈ ↑I ∩ ↓J
48. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Monotone, antimonotone, convex
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
{a, b, c, d}
{a, b, c} {a, b, d} {a, c, d} {b, c, d}
{a, b} {a, c} {a, d} {b, c} {b, d} {c, d}
{a} {b} {c} {d}
∅
1 ≤ #count{a, b, c, d} ≤ 3
S is convex if
I |= S ∧ J |= S =⇒
K |= S ∀K ∈ ↑I ∩ ↓J
49. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Monotone, antimonotone, convex
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
{a, b, c, d}
{a, b, c} {a, b, d} {a, c, d} {b, c, d}
{a, b} {a, c} {a, d} {b, c} {b, d} {c, d}
{a} {b} {c} {d}
∅
1 ≤ #count{a, b, c, d} ≤ 3
S is convex if
I |= S ∧ J |= S =⇒
K |= S ∀K ∈ ↑I ∩ ↓J
50. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Convex Programs
Implicit in [Liu, Truszczy´nski 2006]:
Theorem
FLP and PSP semantics coincide on programs containing only
convex aggregates.
Corollary
FLP and PSP semantics coincide on programs containing only
monotone and antimonotone aggregates.
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
51. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Outline
1 Motivation
2 Basics: Answer Set Programming and Aggregates
3 Semantics
Stratified Aggregates
Unstratified Aggregates
4 Properties
Coincidence Results
Complexity Results
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
52. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Problem
Cautious reasoning over variable-free programs and
polynomial-time computable aggregate functions.
Input: A ground program P and a ground standard atom A.
Output: Is A true in all FLP answer sets of P?
Similar results for related problems (answer set existence,
brave reasoning).
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
53. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Problem
Cautious reasoning over variable-free programs and
polynomial-time computable aggregate functions.
Input: A ground program P and a ground standard atom A.
Output: Is A true in all FLP answer sets of P?
Similar results for related problems (answer set existence,
brave reasoning).
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
54. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Complexity of Cautious Reasoning
{} {not} {∨} {not, ∨}
{M} P co-NP co-NP ΠP
2
{S} P co-NP ΠP
2 ΠP
2
{C} co-NP co-NP ΠP
2 ΠP
2
{N} ΠP
2 ΠP
2 ΠP
2 ΠP
2
{M}: monotone aggregates {S}: stratified aggregates {C}:
convex aggregates {N}: non-convex aggregates
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
55. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Complexity: FLP and PSP
Results for PSP: analogous to FLP
Slight difference for non-convex aggregates [Alviano, F.
2013]:
One non-convex aggregate is sufficient to express any
problem in ΠP
2 with FLP
Arbitrarily many are needed to do the same with PSP
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
56. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Only Aggregates?
All of the results presented here also apply to other extensions
of ASP that have constructs that evaluate truth on sets of basic
atoms, for example:
Abstract Constraint Atoms (U, V) [Marek, Remmel 2004]
HEX programs [Eiter et al. 2005]
Nested Expressions [Lifschitz et al. 1999]
Generalized Quantifiers [Lindström 1966]
Cardinality and Weight Constraints [Simons 2000]
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
57. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
Summary
Aggregates in ASP
FLP and PSP Semantics
Properties: Coincidence and Complexity
Wolfgang Faber Aggregates in Recursion: Issues and Solutions
58. Motivation
Basics: Answer Set Programming and Aggregates
Semantics
Properties
Coincidence Results
Complexity Results
More
Beyond FLP and PSP? [Alviano, F. 2015]
Example
a :- #count{a, b}! = 1.
b :- #count{a, b}! = 1.
No FLP, no PSP answer sets! Unintuitive?
Reduce programs with non-convex aggregates to
programs with monotone aggregates in a compact way.
[Alviano, F., Gebser 2015]
System support: results in [Alviano, F., Gebser 2015] allow
for non-convex aggregates in gringo ≥ 4.5.
Wolfgang Faber Aggregates in Recursion: Issues and Solutions