Tweety
A comprehensive collection of Java libraries for logical aspects of artificial intelligence and knowledge representation
Home Libraries Downloads Documentation Web Interfaces Contact


Brought to you by




Supported by

This page gives an overview on the different libraries of the Tweety collection, together with their Maven dependencies. Technical documentation and the JavaDoc API can be found in the Documentation section. If you are not a Maven user you can also download JARs in the Downloads section.

Maven dependency for the complete collection:
<dependency>
   <groupId>net.sf.tweety</groupId>
   <artifactId>tweety-full</artifactId>
   <version>1.9</version>
</dependency>

The Tweety collection is organized into several libraries that are grouped into sections. You can directly jump to a specific section or library with the following overview:


General Libraries

Commons (net.sf.tweety.commons)

The Commons library contains abstract classes and interfaces for various knowledge representation concepts. Among the most important ones are

  • Formula A formula of a representation formalism.
  • BeliefBase Some structure containing beliefs.
  • BeliefSet A set of beliefs, i.e., a set of formulas, it is the most commonly used class derived from BeliefBase. Please note that we follow the Java guideline for naming a class containing a set of beliefs a belief set (it contains a finite unordered set of elements), opposed to the naming convention in belief dynamics where a belief set is usually deductively closed. In terms of belief dynamics research the class BeliefSet actually represents a belief base.
  • Signature The signature of a representation formalism.
  • Interpretation An interpretation that evaluates the truth of formulas.
  • Reasoner Implements a specific reasoning strategy to answer queries for a representation formalism.
  • Parser, Writer For reading/writing formulas and belief sets.

Most other Tweety libraries provide specific implementations of the above abstract classes and interfaces for their specific representation formalisms. For example, the library Propositional Logic implements Formula by PropositionalFormula (which is recursively defined using conjunction, disjunction, and negation) and Interpretation by PossibleWorld. In this way, the classical approach to formally define a logical language via syntax and semantics has a one-to-one correspondence with its implementation in Tweety.

Besides the above mentioned abstract classes and interfaces, Tweety Commons provides abstract implementations of several other knowledge representation concepts and several utility classes for working with sets, subsets, vectors, and general rules.

Maven dependency for the Commons library:
<dependency>
   <groupId>net.sf.tweety</groupId>
   <artifactId>commons</artifactId>
   <version>1.9</version>
</dependency>

Plugin (net.sf.tweety.plugin)

The Plugin library provides classes for implementing Tweety plugins that can be used by, e.g., the Command Line Interface. This library makes use of the Java Simple Plugin Framework (JSPF). Using these classes one can encapsulate the functionalities of a specific knowledge representation formalism and expose them in the same way to user interfaces. The most important class is the abstract class AbstractTweetyPlugin which is the basis for developing plugins.

Maven dependency for the Plugin library:
<dependency>
   <groupId>net.sf.tweety</groupId>
   <artifactId>plugin</artifactId>
   <version>1.9</version>
</dependency>

Command Line Interface (net.sf.tweety.cli)

All Tweety libraries can be accessed programmatically in Java through their API. However, for non-programmers this way of utilizing the libraries is not very convenient. Using the Plugin library the Command Line Interface library provides a general command line interface for many Tweety libraries. Every library can expose its functionality through a Tweety plugin that can be plugged into the command line interface and accessed in a uniform way.

Maven dependency for the Command Line Interface library:
<dependency>
   <groupId>net.sf.tweety</groupId>
   <artifactId>cli</artifactId>
   <version>1.9</version>
</dependency>

Math (net.sf.tweety.math)

Many algorithms for knowledge representation and reasoning are based on mathematical methods such as optimization techniques. The Math library encapsulates those mathematical methods and exposes them through simple interfaces to other libraries for realizing these algorithms. At the core, the Math library contains classes for representing mathematical terms (such as Constant, Variable, Product, Logarithm) and statements (such as Equation). Using these constructs one can represent, e.g., constraint satisfaction problems (ConstraintSatisfactionProblem) and optimization problems (OptimizationProblem). Through the Solver interface the Math library provides bridges to several third-party solvers such as the Apache Commons Simplex-algorithm, the OpenOpt solvers, or lpsolve.

Maven dependency for the Math library:
<dependency>
   <groupId>net.sf.tweety</groupId>
   <artifactId>math</artifactId>
   <version>1.9</version>
</dependency>

Graphs (net.sf.tweety.graphs)

The Graphs library contains a simple graph implementation with utility functions as it can be used, e.g., to represent abstract argumentation frameworks (see Abstract Argumentation library).

Maven dependency for the Graphs library:
<dependency>
   <groupId>net.sf.tweety</groupId>
   <artifactId>graphs</artifactId>
   <version>1.9</version>
</dependency>

Logic Libraries

The Logic libraries (located under the package net.sf.tweety.logics) provide implementations for various knowledge representation formalisms based on classical logics (propositional logic and first-order logic) and non-classical logics such as conditional logic, probabilistic logics, epistemic logics, or description logic. Each library follows a strict approach in defining the formalism by implementing the abstract classes and interfaces Formula, BeliefBase, Interpretation, ... from the Commons library. Each library contains a sub-package syntax which contains the elements to construct formulas of the formalism and a sub-package semantics which contains elements for realizing the semantics of the formalism. Besides these two common sub-packages many libraries also contain parsers for reading formulas from file and reasoner that implement a specific reasoning approach.

Logic Commons (net.sf.tweety.logic.commons)

The Logic Commons library contains abstract classes and interfaces which further refine the general Formula interface from the Commons library. Among these refinements are several concepts that are shared among a great number of knowledge representation formalism such as Predicate, Variable or Atom.

Maven dependency for the Logic Commons library:
<dependency>
   <groupId>net.sf.tweety.logics</groupId>
   <artifactId>commons</artifactId>
   <version>1.9</version>
</dependency>

Propositional Logic (net.sf.tweety.logic.pl)

The Propositional Logic library provides an implementation of classical propositional logic. Propositional formulas can be constructed using, e.g., classes Conjunction or Disjunction and propositional formulas can be put into a knowledge base of type PlBeliefSet. The Propositional Logic library supports the use of SAT solvers to perform reasoning. More information on this can be found in Integration of SAT solvers.

Maven dependency for the Propositional Logic library:
<dependency>
   <groupId>net.sf.tweety.logics</groupId>
   <artifactId>pl</artifactId>
   <version>1.9</version>
</dependency>

First-Order Logic (net.sf.tweety.logic.fol)

This library contains an implementation of first-order logic as a knowledge representation formalism. Both the Propositional Logic library and the First-Order Logic library are used by many other libraries of knowledge representation formalisms. The First-Order Logic library supports the use of theorem provers to perform reasoning. More information on this can be found in Integration of first-order theorem provers.

Maven dependency for the First-Order Logic library:
<dependency>
   <groupId>net.sf.tweety.logics</groupId>
   <artifactId>fol</artifactId>
   <version>1.9</version>
</dependency>

Conditional Logic (net.sf.tweety.logic.cl)

The Conditional Logic library extends the Propositional Logic library by conditionals, i.e., non-classical rules of the form (B|A) ("A usually implies B"), cf. [Nute:2002]. In the literature, several different semantics and reasoning approaches for conditional logics have been proposed and this library can be used to easily compare their reasoning behavior. Currently, the Conditional Logic library implements interpretations in the form of ranking functions [Spohn:1988] and conditional structures [Kern-Isberner:2001b], and provides reasoner based on z-ranking [Goldszmidt:1996] and c-representations [Kern-Isberner:2001b].

Maven dependency for the Conditional Logic library:
<dependency>
   <groupId>net.sf.tweety.logics</groupId>
   <artifactId>cl</artifactId>
   <version>1.9</version>
</dependency>

Relational Conditional Logic (net.sf.tweety.logic.rcl)

Similar to the Conditional Logic library the Relational Conditional Logic extends the First-Order Logic library with relational conditionals (i.e. conditionals that may contain first-order formulas), cf. [Delgrande:1998], [Kern-Isberner:2012]. Currently, this library contains an implementation of the relational c-representation reasoning approach of [Kern-Isberner:2012].

Maven dependency for the Relational Conditional Commons library:
<dependency>
   <groupId>net.sf.tweety.logics</groupId>
   <artifactId>rcl</artifactId>
   <version>1.9</version>
</dependency>

Probabilistic Conditional Logic (net.sf.tweety.logic.pcl)

This library further extends the Conditional Logic library by extending conditionals to probabilistic conditionals of the form (B|A)[p] ("A usually implies B with probability p"), cf. [Rodder:2000]. Besides a naive implementation of probabilistic reasoning based on the principle of maximum entropy [Paris:1994] this library also contains several classes for analyzing and repairing inconsistent sets of probabilistic conditionals, cf. [Thimm:2011e], [Thimm:2013].

Maven dependency for the Probabilistic Conditional Logic library:
<dependency>
   <groupId>net.sf.tweety.logics</groupId>
   <artifactId>pcl</artifactId>
   <version>1.9</version>
</dependency>

Relational Probabilistic Conditional Logic (net.sf.tweety.logic.rpcl)

By combining both the Relational Conditional Logic and Probabilistic Conditional Logic libraries the Relational Probabilistic Conditional Logic library introduces relational conditionals with probabilities, cf. [Kern-Isberner:2010]. It implements both the averaging and aggregating semantics from [Kern-Isberner:2010] and also allows for lifted inference as proposed in [Thimm:2011e].

Maven dependency for the Relational Probabilistic Conditional Logic library:
<dependency>
   <groupId>net.sf.tweety.logics</groupId>
   <artifactId>rpcl</artifactId>
   <version>1.9</version>
</dependency>

Reiter's Default Logic (net.sf.tweety.logic.rdl)

The Reiter's Default Logic library provides a general implementation of Reiter's Default Logic [Reiter:1980] based on the First-Order Logic library.

Maven dependency for the Reiter's Default Logic library:
<dependency>
   <groupId>net.sf.tweety.logics</groupId>
   <artifactId>rdl</artifactId>
   <version>1.9</version>
</dependency>

Markov Logic (net.sf.tweety.logic.ml)

This library builds on the First-Order Logic library to implement Markov Logic, an extension of first-order logic with weights to allow for probabilistic reasoning, cf. [Richardson:2006]. It provides several propriety sampling-based reasoner and a bridge to the Alchemy reasoner.

Maven dependency for the Markov Logic library:
<dependency>
   <groupId>net.sf.tweety.logics</groupId>
   <artifactId>ml</artifactId>
   <version>1.9</version>
</dependency>

Epistemic Logic (net.sf.tweety.logic.el)

This library extends the Propositional Logic library with modal operators for epistemic logic and its semantics with accessibility relations and Kripke models. Please note that the Epistemic Logic library is currently in an experimental phase.

Maven dependency for the Epistemic Logic library:
<dependency>
   <groupId>net.sf.tweety.logics</groupId>
   <artifactId>el</artifactId>
   <version>1.9</version>
</dependency>

Description Logic (net.sf.tweety.logic.dl)

The Description Logic library provides a general description logic implementation [Baader:2003] based on the First-Order Logic library. Please note that the Description Logic library is currently in an experimental phase.

Maven dependency for the Description Logic library:
<dependency>
   <groupId>net.sf.tweety.logics</groupId>
   <artifactId>dl</artifactId>
   <version>1.9</version>
</dependency>

Logic Translators (net.sf.tweety.logic.translators)

This library provides the abstract class Translator that provides basic functionalities to implement translators between different knowledge representation formalisms. Currently, the Logic Translators library contains translators between first-order logic and answer set programming, between nested logic programming and answer set programming, and between propositional logic and first-order logic.

Maven dependency for the Logic Translators library:
<dependency>
   <groupId>net.sf.tweety.logics</groupId>
   <artifactId>translators</artifactId>
   <version>1.9</version>
</dependency>

Logic Programming Libraries

The Logic Programming libraries (located under the package net.sf.tweety.lp) provide implementations of knowledge representation formalisms based on logic programming.

Answer Set Programming (net.sf.tweety.lp.asp)

The Answer Set Programming library provides classes for representing extended logic programs [Gelfond:2002]. Answer set programs are logic programs of the form A←B1,...,Bm with first-order literals A, B1,..., Bm where the body literals B1,...,Bm may also have a default negation not. This library provides bridges to several established solvers such as DLV, DLV Complex, and Clingo.

Maven dependency for the Answer Set Programming library:
<dependency>
   <groupId>net.sf.tweety.lp</groupId>
   <artifactId>asp</artifactId>
   <version>1.9</version>
</dependency>

Dynamics in Answer Set Programming (net.sf.tweety.lp.asp.beliefdynamics)

This library extends theAnswer Set Programming library by introducing revision and update approaches. The library contains implementations of the approaches introduced in [Kruempelmann:2012], [Delgrande:2007] and also revision approaches based on argumentation.

Maven dependency for the Dynamics in Answer Set Programming library:
<dependency>
   <groupId>net.sf.tweety.lp.asp</groupId>
   <artifactId>beliefdynamics</artifactId>
   <version>1.9</version>
</dependency>

Nested Logic Programs (net.sf.tweety.lp.nlp)

This library contains an implementation of nested logic programs which allow for complex first-order formulas to appear in logic programming rules [Lifschitz:1999].

Maven dependency for the Nested Logic Programs library:
<dependency>
   <groupId>net.sf.tweety.lp</groupId>
   <artifactId>nlp</artifactId>
   <version>1.9</version>
</dependency>

Argumentation Libraries

The argumentation libraries (located under the package net.sf.tweety.arg) are one of the most mature libraries of Tweety and contain a wide variety of implementations of different approaches to computational argumentation.

Abstract Argumentation (net.sf.tweety.arg.dung)

This library implements abstract argumentation as proposed in [Dung1995]. An abstract argumentation framework is a directed graph (A,Att) where A is interpreted as a set of arguments and an edge (A,A')∈ Att is an attack of A on A'. The library provides implementations of the mostly used semantics and their corresponding reasoner, both in terms of extensions (an extension is a set of arguments that is regarded as accepted by a semantics) and labelings (a labeling is a function with a three-valued truth assignment to each argument). Several utility classes for generating random argumentation frameworks complement this library.

Maven dependency for the Abstract Argumentation library:
<dependency>
   <groupId>net.sf.tweety.arg</groupId>
   <artifactId>dung</artifactId>
   <version>1.9</version>
</dependency>

ABA (net.sf.tweety.arg.aba)

The ABA library provides an implementation of the approach proposed in [Toni:2014]. An ABA theory instantiates an abstract argumentation framework by adding structure to arguments in the form of assumptions and rules. Please note that the ABA library is currently in an experimental phase.

Maven dependency for the ABA library:
<dependency>
   <groupId>net.sf.tweety.arg</groupId>
   <artifactId>aba</artifactId>
   <version>1.9</version>
</dependency>

Abstract Dialectical Frameworks (net.sf.tweety.arg.adf)

The Abstract Dialectical Frameworks library provides an implementation of the approach proposed in [Brewka:2013]. An abstract dialectical framework is an extension of an abstract argumentation framework that allows specific acceptance conditions for arguments to be formalized. Please note that the Abstract Dialectical Frameworks library is currently in an experimental phase.

Maven dependency for the Abstract Dialectical Frameworks library:
<dependency>
   <groupId>net.sf.tweety.arg</groupId>
   <artifactId>adf</artifactId>
   <version>1.9</version>
</dependency>

ASPIC+ (net.sf.tweety.arg.aspic)

The ASPIC+ library provides an implementation of the approach proposed in [Modgil:2014]. An ASPIC+ theory instantiates an abstract argumentation framework by adding structure to arguments in the form of defeasible and strict rules.

Maven dependency for the ASPIC+ library:
<dependency>
   <groupId>net.sf.tweety.arg</groupId>
   <artifactId>aspic</artifactId>
   <version>1.9</version>
</dependency>

Deductive Argumentation (net.sf.tweety.arg.deductive)

The Deductive Argumentation library provides an implementation of the approach proposed in [Besnard:2001]. In deductive argumentation, an argument is composed of a set of propositional formulas that derive the claim of the argument. Attack between arguments is derived from classical unsatisfiability.

Maven dependency for the Deductive Argumentation library:
<dependency>
   <groupId>net.sf.tweety.arg</groupId>
   <artifactId>deductive</artifactId>
   <version>1.9</version>
</dependency>

Social Abstract Argumentation (net.sf.tweety.arg.social)

This library implements the approach of social abstract argumentation frameworks as proposed in [Leite:2011]. In social abstract argumentation framework extends an abstract argumentation framework by introducing positive and negative votes to arguments and a quantitative semantics to evaluate those.

Maven dependency for the Social Abstract Argumentation library:
<dependency>
   <groupId>net.sf.tweety.arg</groupId>
   <artifactId>social</artifactId>
   <version>1.9</version>
</dependency>

Structured Argumentation (net.sf.tweety.arg.saf)

This library implements the approach of structured argumentation frameworks as proposed in [Thimm:2010]. In structured argumentation frameworks arguments are composed of subarguments and a conclusion.

Maven dependency for the Structured Argumentation library:
<dependency>
   <groupId>net.sf.tweety.arg</groupId>
   <artifactId>saf</artifactId>
   <version>1.9</version>
</dependency>

Defeasible Logic Programming (net.sf.tweety.arg.delp)

This library provides an implementation of Defeasible Logic Programming (DeLP) [Garcia:2004a]. In DeLP knowledge bases contain strict and defeasible rules and facts, similar to knowledge representation formalisms for logic programming. Defeasible rules can be collected in arguments and compared by generalized specificity [Stolzenburg:2003].

Maven dependency for the Defeasible Logic Programming library:
<dependency>
   <groupId>net.sf.tweety.arg</groupId>
   <artifactId>delp</artifactId>
   <version>1.9</version>
</dependency>

Logic Programming Argumentation (net.sf.tweety.arg.lp)

This library provides an implementation of the argumentation approach of [Schweimeier:2003] which is also based on logic programming techniques.

Maven dependency for the Logic Programming Argumentation library:
<dependency>
   <groupId>net.sf.tweety.arg</groupId>
   <artifactId>lp</artifactId>
   <version>1.9</version>
</dependency>

Probabilistic Argumentation (net.sf.tweety.arg.prob)

The Probabilistic Argumentation library extends the Abstract Argumentation library with non-classical semantics based on probabilistic assessments [Thimm:2012].

Maven dependency for the Probabilistic Argumentation library:
<dependency>
   <groupId>net.sf.tweety.arg</groupId>
   <artifactId>prob</artifactId>
   <version>1.9</version>
</dependency>

Agent Libraries

The agent libraries (located under the package net.sf.tweety.agents) provide a framework for analyzing and simulating interactions between agents.

Agents (net.sf.tweety.agents)

This general library contains an abstract formalization of agents and multi-agent systems. Classes such as Agent, Environment, MultiAgentSystem, and Protocol can be used to set up and simulate a system of agents within an environment. This library has a specific focus on the simulation aspect and provides classes such as MultiAgentSystemGenerator and GameSimulator that allow the automatic generation of test scenarios and their evaluation.

Maven dependency for the Agents library:
<dependency>
   <groupId>net.sf.tweety</groupId>
   <artifactId>agents</artifactId>
   <version>1.9</version>
</dependency>

Dialogues (net.sf.tweety.agents.dialogues)

The library Dialogues extends the Agents library with the capability of simulating dialogues between agents, as they are investigated in the context of argumentation in multi-agent systems [Karunatillake:2009]. It also provides an implementation of agents with an opponent model as proposed in [Rienstra:2013].

Maven dependency for the Dialogues library:
<dependency>
   <groupId>net.sf.tweety.agents</groupId>
   <artifactId>dialogues</artifactId>
   <version>1.9</version>
</dependency>

Other Libraries

The above discussed libraries constitute the core of Tweety by providing implementations of several knowledge representation formalisms. This collection is complemented by some further libraries that relate either to topics that do not strictly belong to the field of knowledge representation (such as the Machine Learning library) or can be applied across several different knowledge representation formalisms (such as the Belief Dynamics library).

Action and Change (net.sf.tweety.action)

The Action and Change library implements several action languages and their dynamics from [Gelfond:1999].

Maven dependency for the Action and Change library:
<dependency>
   <groupId>net.sf.tweety</groupId>
   <artifactId>action</artifactId>
   <version>1.9</version>
</dependency>

Belief Dynamics (net.sf.tweety.beliefdynamics)

This library provides a general implementation for various approaches to belief (base) revision and update [Hansson:2001]. It provides interfaces and several implementations of many concepts used in belief dynamics such as BaseRevisionOperator, BaseContractionOperator, IncisionFunction, and LeviBaseRevisionOperator. Those classes are defined in such a general way that they can be used not only to implement belief dynamics for propositional logic but also for other knowledge representation formalisms implementing the corresponding Tweety interfaces. This library contains also specific revision approaches such as selective revision [Ferme:1999] and argumentative selective revision [Krumpelmann:2011].

Maven dependency for the Belief Dynamics library:
<dependency>
   <groupId>net.sf.tweety</groupId>
   <artifactId>beliefdynamics</artifactId>
   <version>1.9</version>
</dependency>

Machine Learning (net.sf.tweety.machinelearning)

The Machine Learning library provides several abstract concepts that can be used in a machine learning context such as Observation, Classifier, and CrossValidator. It contains also an implementation of support vector machines utilizing LIBSVM.

Maven dependency for the Machine Learning library:
<dependency>
   <groupId>net.sf.tweety</groupId>
   <artifactId>machinelearning</artifactId>
   <version>1.9</version>
</dependency>

Preferences (net.sf.tweety.preferences)

This library contains classes for representing preference orders and approaches for aggregating them [Walsh:2007]. It also contains an implementation of the dynamic preference aggregation approach proposed in [Thimm:2013a].

Maven dependency for the Preferences library:
<dependency>
   <groupId>net.sf.tweety</groupId>
   <artifactId>preferences</artifactId>
   <version>1.9</version>
</dependency>

Web (net.sf.tweety.web)

This library contains classes for exposing Tweety functionalities through web services.

Maven dependency for the Web library:
<dependency>
   <groupId>net.sf.tweety</groupId>
   <artifactId>web</artifactId>
   <version>1.9</version>
</dependency>

[Baader:2003] Baader, F.; Calvanese, D.; McGuinness, D. L.; Nardi, D.; and Patel-Schneider, P. F., eds. 2003. The Description Logic Handbook: Theory, Implementation, and Applications. New York, NY, USA: Cambridge University Press.
[Besnard:2001] Besnard, P., and Hunter, A. 2001. A logic-based theory of deductive arguments. Artificial Intelligence 128(1-2):203-235.
[Brewka:2013] Brewka, G., Ellmauthaler, S., Strass, H., Wallner, J.P., and Woltran, S. 2013. Abstract Dialectical Frameworks Revisited. In Proceedings of the 23rd International Joint Conference on Artificial Intelligence (IJCAI'13), 2013.
[Delgrande:1998] Delgrande, J. P. 1998. On first-order conditional logics. Artificial Intelligence 105(1-2):105-137.
[Delgrande:2007] Delgrande, J.P.; Schaub, T.; and Tompits, H. 2007. A preference-based framework for updating logic programs. In Proceedings of the Ninth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR'07).
[Dung:1995] Dung, P.M. 1995. On the Acceptability of Arguments and its Fundamental Role in Nonmonotonic Reasoning, Logic Programming and n-Person Games. Artificial Intelligence 77(2):321-358.
[Ferme:1999] Ferme, E., and Hansson, S.O. 1999. Selective Revision. Studia Logica 63(3):331-342.
[Garcia:2004a] Garcia, A., and Simari, G. R. 2004. Defeasible Logic Programming: An argumentative approach. Theory and Practice of Logic Programming 138(1-2):95-138.
[Gelfond:1999] Gelfond, M., and Lifschitz, V. 1998. Action languages. Electronic Transactions on AI 2:192-210.
[Gelfond:2002] Gelfond, M., and Leone, N. 2002. Logic Programming and knowledge representation - the A-Prolog perspective. Artificial Intelligence 138(1-2):3-38.
[Goldszmidt:1996] Goldszmidt, M., and Pearl, J. 1996. Qualitative probabilities for default reasoning, belief revision, and causal modeling. Artificial Intelligence 84:57-112.
[Hansson:2001] Hansson, S.O. 2001. A Textbook on Belief Dynamics. Norwell, MA, USA: Kluwer Academic Publishers.
[Karunatillake:2009] Karunatillake, N.C.; Jennings, N.R.; Rahwan, I.; and McBurney, P. 2009. Dialogue Games that Agents Play within a Society. Artificial Intelligence 173(9-10):935-981.
[Kern-Isberner:2001b] Kern-Isberner, G. 2001. Conditionals in Nonmonotonic Reasoning and Belief Revision. Number 2087 in Lecture Notes in Computer Science. Springer-Verlag.
[Kern-Isberner:2010] Kern-Isberner, G., and Thimm, M. 2010. Novel semantical approaches to relational probabilistic conditionals. In Lin, F.; Sattler, U.; and Truszczynski, M., eds., Proceedings of the Twelfth International Conference on the Principles of Knowledge Representation and Reasoning (KR'10), 382-392. AAAI Press.
[Kern-Isberner:2012] Kern-Isberner, G., and Thimm, M. 2012. A ranking semantics for first-order conditionals. In Proceedings of the 20th European Conference on Artificial Intelligence (ECAI'12).
[Krumpelmann:2011] Krümpelmann, P.; Thimm, M.;Falappa, M.A.; Garcia, A.J.; Kern-Isberner, G.; and Simari, G. R. 2011. Selective revision by deductive argumentation. In Modgil, S.; Oren, N.; and Toni, F., eds., Theory and Applications of Formal Argumentation, Proceedings of the First International Workshop (TAFA'11, revised selected papers), volume 7132 of Lecture Notes in Artificial Intelligence, 147-162. Springer.
[Kruempelmann:2012] Krümpelmann, P., and Kern-Isberner, G. 2012. Belief base change operations for answer set programming. In Cerro, L. F.; Herzig, A.; and Mengin, J., eds., Proceedings of the 13th European conference on Logics in Artificial Intelligence (JELIA'12), 294-306. Springer.
[Leite:2011] Leite, J., Martins, J. 2011. Social Abstract Argumentation. In Proceedings of the 22nd International Joint Conference on Artificial Intelligence (IJCAI'11).
[Lifschitz:1999] Lifschitz, V.; Tang, L. R.; and Turner, H. 1999. Nested expressions in logic programs. Annals of Mathematics and Artificial Intelligence 25:369-389.
[Modgil:2014]Modgil, S. and Prakken, H.. The ASPIC+ framework for structured argumentation: a tutorial. Argument and Computation 5 (2014): 31-62
[Nute:2002] Nute, D., and Cross, C. 2002. Conditional logic. In Gabbay, D., and Guenther, F., eds., Handbook of Philosophical Logic, volume 4. Kluwer Academic Publishers, second edition. 1-98.
[Paris:1994] Paris, J. B. 1994. The Uncertain Reasoner's Companion - A Mathematical Perspective. Cambridge University Press.
[Reiter:1980] Raymond Reiter. A logic for default reasoning. Artificial Intelligence, 13:81-132, 1980
[Richardson:2006] Richardson, M., and Domingos, P. 2006. Markov logic networks. Machine Learning 62(1-2):107-136.
[Rienstra:2013] Rienstra, T.; Thimm, M.; and Oren, N. 2013. Opponent models with uncertainty for strategic argumentation. In Proceedings of the 23rd International Joint Conference on Artificial Intelligence (IJCAI'13).
[Rodder:2000] Rödder, W. 2000. Conditional logic and the principle of entropy. Artificial Intelligence 117:83-106.
[Schweimeier:2003] Schweimeier, R., and Schroeder, M. 2003. A parameterised hierarchy of argumentation semantics for extended logic programming and its application to the well-founded semantics. Theory and Practice of Logic Programming 5(1-2):207-242.
[Spohn:1988] Spohn, W. 1988. Ordinal conditional functions: a dynamic theory of epistemic states. In Harper, W., and Skyrms, B., eds., Causation in Decision, Belief Change, and Statistics, volume 2. Kluwer Academic Publishers. 105-134.
[Stolzenburg:2003] Stolzenburg, F.; Garcia, A.; Chesnevar, C. I.; and Simari, G. R. 2003. Computing generalized specificity. Journal of Non-Classical Logics 13(1):87-113.
[Thimm:2010] Thimm, M., and Garcia, A. J. 2010. Classification and Strategical Issues of Argumentation Games on Structured Argumentation Frameworks. In van der Hoek, W.; Kaminka, G. A.; Lesperance, Y.; Luck, M.; and Sen, S., eds., Proceedings of the Ninth International Joint Conference on Autonomous Agents and Multi-Agent Systems 2010 (AAMAS'10).
[Thimm:2011e] Thimm, M. 2011. Probabilistic Reasoning with Incomplete and Inconsistent Beliefs, volume 331 of Dissertations in Artificial Intelligence. IOS Press.
[Thimm:2012] Thimm, M. 2012. A probabilistic semantics for abstract argumentation. In Proceedings of the 20th European Conference on Artificial Intelligence (ECAI'12).
[Thimm:2013] Thimm, M. 2013. Inconsistency measures for probabilistic logics. Artificial Intelligence 197:1-24.
[Thimm:2013a] Thimm, M. 2013. Dynamic preference aggregation under preference changes. In Proceedings of the Fourth Workshop on Dynamics of Knowledge and Belief (DKB'13).
[Toni:2014] Toni, F. 2014. A tutorial on assumption-based argumentation. Argument and Computation 5:89-117.
[Walsh:2007] Walsh, T. 2007. Representing and reasoning with preferences. AI Magazine 28(4):59-70.



Last updated 13.07.2017, Matthias Thimm