Hannes Strass’s research while affiliated with TU Dresden and other places

We present the RFuzzy framework, a Prolog-based tool for representing and reasoning with fuzzy information. The advantages of our framework in comparison to previous tools along this line of research are its easy, user-friendly syntax, and its expressivity through the availability of default values and types.In this approach we describe the formal syntax, the operational semantics and the declarative semantics of RFuzzy (based on a lattice). A least model semantics, a least fixpoint semantics and an operational semantics are introduced and their equivalence is proven. We provide a real implementation that is free and available. (It can be downloaded from http://babel.ls.fi.upm.es/software/rfuzzy/.) Besides implementation details, we also discuss some actual applications using RFuzzy.

Reasoning agents are often faced with the need to robustly deal with erroneous information. When a robot given the task of returning with the red cup from the kitchen table arrives in the kitchen to find no red cup but instead notices a blue cup and a red plate on the table, what should it do? The best course of action is to attempt to salvage the situation by relying on its preferences to return with one of the objects available. We provide a solution to this problem using the Situation Calculus extended with a notion of belief. We then provide an efficient practical implementation by mapping this formalism into default rules for which we have an implemented solver.

We present a framework for reasoning about actions that not only solves the frame and ramification problems, but also the state default problem-the problem to determine what normally holds at a given time point. Yet, the framework is general enough not to be tied to a specific time structure. This is achieved as follows: We use effect axioms that draw ideas both from Reiter's successor state axioms and the nonmonotonic causal theories by Giunchiglia et al. These axioms are formulated in a recently proposed unifying action calculus to guarantee independence of a specific underlying notion of time. Reiter's default logic is then wrapped around the resulting calculus and plays a key role in solving the ramification as well as the state default problem. Copyright © 2010, Association for the Advancement of Artificial Intelligence.

We extend a recent approach to integrate action formalisms and non-monotonic reasoning. The resulting framework allows an agent employing an action theory as internal world model to make useful default assumptions. While the previous approach only allowed for modeling static defaults, that are independent of state properties, our extension allows for the expression of dynamic defaults. Problems that arise due to the interaction of defaults with the solution of the frame problem are dealt with accordingly: we devise a general method of integrating defaults into the formal representation of action effects and show that the method prevents counter-intuitive conclusions.

We study the integration of two prominent elds of logic- based AI: action formalisms and non-monotonic reasoning. The resulting framework allows an agent employing an action theory as internal world model to make useful default assumptions. We show that the mechanism behaves properly in the sense that all intuitively possible conclusions can be drawn and no implausible inferences arise. In particular, it suces to make default assumptions only once (in the initial state) to solve projection problems.

Fuzzy Logic Programming aims at combining the advantages of Logic Programming (such as readability, conciseness, and a formally well-defined semantics) with the advantages of Fuzzy Logic (representability of imprecise and uncertain knowledge). In this paper, we present the RFuzzy framework for Fuzzy Logic Programming. It has three main advantages compared to other Fuzzy Logic Programming frameworks: RFuzzy provides constructive answers (it responds with direct results instead of constraints), models multi-adjoint logic, and allows the user1 to combine fuzzy and crisp reasoning in the same program. It provides some extensions such as default values (to represent missing information) and typed predicates. The truth values of predicates are defined via facts, rules, and functions. We describe the implementation of our framework and its operational semantics. RFuzzy has been implemented and is ready for being used2.

Fuzzy reasoning is a very productive research field that during the last years has provided a number of theoretical approaches and practical implementation prototypes. Nevertheless, the classical implementations, like Fril, are not adapted to the latest formal approaches, like multi-adjoint logic semantics. Some promising implementations, like Fuzzy Prolog, are so general that the regular user/programmer does not feel comfortable because either the representation of fuzzy concepts is complex or the results of the fuzzy queries are difficult to interpret. In this paper we present a modern framework, RFuzzy, that is modeling multi-adjoint logic in a practical way. It provides some extensions as default values (to represent missing information), partial default values (for a subset of data) and typed variables. RFuzzy represents the truth value of predicates using facts, rules and also can define fuzzy predicates as continuous functions. Queries are answered with direct results (instead of providing complex constraints), so it is easy to use for any person that wants to represent a problem using fuzzy reasoning in a simple way (just using the classical fuzzy representation with real numbers). The most promising characteristic of RFuzzy is that the user can obtain constructive answers to queries that restrict the truth value.

Fuzzy reasoning is a very productive research field that during the last years has provided a number of theoretical approaches and practical implementation prototypes. Nevertheless, the classical implementations, like Fril, are not adapted to the latest formal approaches, like multi-adjoint logic semantics. Some promising implementations, like Fuzzy Prolog, are so general that the regular user/programmer does not feel comfortable because either representation of fuzzy concepts is complex or the results difficult to interpret. In this paper we present a modern framework, Rfuzzy, that is modelling multi-adjoint logic. It provides some extensions as default values (to represent missing information, even partial default values) and typed variables. Rfuzzy represents the truth value of predicates through facts, rules and functions. Rfuzzy answers queries with direct results (instead of constraints) and it is easy to use for any person that wants to represent a problem using fuzzy reasoning in a simple way (by using the classical representation with real numbers).

In this paper we present the operational semantics of RFuzzy, a fuzzy Logic Programming framework that represents thruth values using real numbers from the unit interval. RFuzzy pro- vides some useful extensions: default values to represent missing in- formation, and typed terms to intuitively restrict predicate domains. Together, they allow the system to give constructive answers in addi- tion to truth values. RFuzzy does not confine to a particular Fuzzy Logic, but aims at being as general as possible by using the notion of aggregation operators.

We propose a mechanism for default reasoning in action for-malisms that allows to make useful assumptions unless infor-mation to the contrary. The mechanism is shown to behave properly when actions are performed, in particular we show that it suffices to apply defaults to the initial state. This allows for very simple reasoning, since the defaults need only be ap-plied once and monotonic entailment can thence be used to solve projection problems. We finally consider two simple, natural generalizations of the approach and show that they admit unintuitive conclusions, thereby pointing out directions for further research.