All Classes and Interfaces

Class
Description
 
This class models an ABA attack.
Abstract class that models common properties of aba syntax elements.
Shows some simple code for working with ABA, including how to parse an ABA file and how to ask queries.
This class models an ABA Extension, meaning a set of assumptions.
*description missing*
Parses a Assumption Based Argumentation System out of an input text.
*description missing*
*description missing*
*description missing*
*description missing*
*description missing*
*description missing*
*description missing*
AbaRule<T extends Formula>
A common interface for assumptions and inference rules.
Test class for ABA.
An implementation of Assumption Based Argumentation.
This class models the absolute value of the inner term.
Ancestor class for reasoners that are tailored towards computing the set {a | a is credulously/skeptically accepted wrt.
AbstractAnalysis provides utility functions for concrete implementations
Example code for applying belief dynamics on abstract argumentation frameworks.
Example code for applying belief dynamics on abstract argumentation frameworks.
This abstract class acts as a common ancestor for interpretations to abstract argumentation frameworks.
The abstract ancestor of all Aspic reasoner implementations
Abstract layer for association rule miners, bundles common methods.
Classes extending this abstract class are capable of testing whether a given belief set is consistent.
This class implements a bipolar abstract argumentation framework with attack and support relations.
 
Ancestor class for all claim based reasoner.
This class represents an abstract coherence measure, i.e.
Similar to AbstractTransformer but is designed for collections and therefore provides Collector functionality for free.
Abstract ancestor for all reasoner for conditional logic.
This class provides for auxiliary functions used to compare formulas and proofs of formulas wrt.
The common ancestor vor creeping machine shops, see [Diss, Thimm] for details.
This class contains common characteristics for deductive argumentation reasoner.
The implementing subtypes must ensure the following properties: Immutability All methods return a non-null value if its parameters, e.g.
 
Deprecated, for removal: This API element is subject to removal in a future version.
This abstract class gives a template for parsers of files representing abstract argumentation frameworks.
Ancestor class for all AAF reasoners.
Writes an abstract argumentation framework into a file of a specific format.
A base class for implementing PEAFTheory and EAFTheory.
 
 
Ancestor class for all extension-based reasoners.
Main factory for retrieving inconsistency measures for propositional logic.
An enumeration of all available inconsistency measures.
Ancestor class for all SetAf-extension-based reasoners.
Provides common functionalities for the graph-based modalities in LDO.
An abstract interpretation for some logical language.
Provides common functionalities for all modalities in LDO.
An agent in a game of argumentation lotteries.
This class provides common methods for MLN reasoner.
Abstract modal reasoner to be implemented by concrete reasoners.
Abstract implementation for MUes enumerators.
Provides common functionality for change operators based on probabilistic semantics.
Abstract anecestor for PAF reasoner.
This class bundles common answering behaviour for probabilistic argumentation semantics.
Abstract class for all PCL reasoners.
AbstractPEAFInducer includes helper functions for concrete implementations
Abstract class for propositional logic reasoners.
A protocol gives instructions in which order agents have to be asked for actions in a multi-agent system.
Common abstract class for ranking reasoners for abstract argumentation.
Abstract class for real vector norms.
This class bundles common answering behaviour for relational conditional semantics.
Uses a provided SAT solver to solve reasoning problems in AAFs.
Ancestor class for all Setaf reasoners.
This is the abstract ancestor of concrete semantics for social abstract argumentation frameworks, cf.
 
This abstract class implements the TweetyPlugin interface and provides a base for plugin implementations in each project
 
This example shows how the different acceptability reasoners work.
An immutable representation of acceptance conditions for ADFs.
 
Deprecated, for removal: This API element is subject to removal in a future version.
not used anymore
 
This class models an accessibility relation for Kripke models.
Classes implementing this interface represent accumulators in the sense of Definition 8.11 in

Philippe Besnard and Anthony Hunter.
An action in a Markov Decision Process
This class represents an action description as a set of causal laws.
Classes implementing this interface are capable of checking whether a given action description is consistent according to some consistency measurements.
An action event encapsulates a multi agent system, an agent in this system, and an action (which was performed by the agent).
This is a basic interface for action queries.
This class implements a parser for action queries in S.
Classes implementing this interface are capable of checking whether a transition system satisfies an action query.
An Action Query Set consists of action queries in a specific query language and provides some common functionalities for such queries.
This class represents an action signature consisting of a set of fluent names (representing environment states) and a set of action names (representing actions).
This class implements a parser for signatures of action descriptions.
A class to represent Activities in a BPMN Model
Example code illustrating Abstract Dialectical Frameworks (ADFs) with different semantics.
Admissibility Principle A semantics satisfies admissibility if for all extensions E it holds that: every argument in E is defended by E see Baroni, P., and Giacomin, M.
 
Kernel SK = (A, R') for strong equivalence wrt.
Maximizes a given interpretation, but only counts admissible interpretations as larger.
Deprecated, for removal: This API element is subject to removal in a future version.
a set of arguments S is admissible iff it is conflict-free and all elements of S are acceptable wrt.
a set of arguments S is admissible iff it is strongly coherent and defends all of its arguments.
Interface for the learning algorithm
Showcasing how to use the implementation of the learning algorithm
An agent is a possibly proactive entity situated in some environment.
This interface defines an agent template that is used to generate agents following some common characteristics.
This class represents an aggregate.
This class models an aggregate element, meaning a set of terms and a set of naf literals (= literals or default negated literals).
Some more examples on how aggregates work.
This class is a variant of the basic ASP rule head.
This coherence measure uses an aggregation function and a distance function to measure the coherence of an MLN.
This norm uses an aggregator on the 1-norm distance of each value.
This class implements aggregating semantics due to [Kern-Isberner, Thimm, KR'2010].
This class aggregates a list of doubles to a single double.
Example code illustrating the use of the Alchemy reasoner.
This class implements a wrapper for Alchemy in order to reason with MLNs.
 
This class represents an always query in the action query language S.
The interface of the analyses in arg.peaf
Example code illustrating the use of inconsistency measures and repairing approaches.
A record for storing analysis of the results
The types of analysis supported by arg.peaf
An answer set is a belief set which only contains literals and represents the deductive belief set of an extended logic program under the answer set semantic.
This class implements the ant colony algorithm using isula (https://github.com/cptanalatriste/isula) for combinatrics problems
This class is a wrapper for the Apache Commons Math3 CMAES optimizer (https://commons.apache.org/proper/commons-math/).
This class implements an example for the ApacheCommonsCMAESOptimizer
 
This class is a wrapper for the Apache Commons Math3 Non-Linear Conjugate Gradient Optimizer (https://commons.apache.org/proper/commons-math/).
This class implements an example for the ApacheCommonsNonLinearConjugateGradientOptimizer
This class is a wrapper for the Apache Commons Math Simplex implementation.
This class implements an example for the Apache Commons SimplexSolver.
This class is a second example for the ApacheCommonsSimplexSolver.
This class implements approximate probabilistic justification of a set of queries using Monte Carlo Sampling of induced EAFs from a PEAF.
 
This reasoner performs approximate reasoning with MLNs by considering only a subset of all Herbrand interpretations.
Example code illustrating the use of the sampling-based MLN reasoner.
ApproxPEAFInducer induces a set of random EAFs from a PEAF
Implements the classical Apriori algorithm for association rule mining, cf.
 
Filename filter for APX files.
Parses abstract argumentation frameworks in the logic programming format which is given by the following BNF (start symbol is S):

S ::== "" | "arg" "(" ARGUMENT ")" "\n" S | "att" "(" ARGUMENT "," ARGUMENT ")" "\n" S
where "ARGUMENT" represents any string (without blanks) as a terminal symbol.
Writes an abstract argumentation framework into a file of the APX format.
This class represent a general arguing agent with an belief state.
An immutable representation of an ADF argument
This class models an argument used by Dung's abstract argumentation theory and is just described by its name.
Instances of this class represent arguments in the sense of Definition 2 in [1].
This class models the environment for agents in argumentation games.
*description missing*
Instances of this class represent the set of minimal arguments from a extended logic program
This class implements an argumentation lottery, i.e.
This class models a reasoner for extended logic programming based arguments using the fixpoint semantics from [1] parameterised by a notion of attack x for the opponent and another notion of attack y as a defense for the proponent.
 
This class is an exemplary instantiation of a revision operator based on deductive argumentation [Kruempelmann:2011] where several parameters have been fixed: - the inner revision is a Levi revision which bases on the random kernel contraction - the transformation function is credulous - the accumulator used for deductive argumentation is the simple accumulator - the categorizer used for deductive argumentation is the classical categorizer
This class implements a comparison application for selective revision operators using the SimpleRevisionCompare gui.
This class implements the argumentative transformation functions proposed in [Kruempelmann:2011].
This class models a set of arguments used by bipolar abstract argumentation theory.
This enumeration enumerates the classical justification status of an argument.
This class models an argument structure, i.e.
Instances of this class represent argument trees in the sense of Definition 6.1 in

Philippe Besnard and Anthony Hunter.
This class represents an arithmetic term in the ASP-Core-2 format.
A class to describe arks in a Petri net
 
This class models an atom, which is a basic structure for building literals and rules for logic programs.
This class is a common base class for ASP formulas that can be part of an ASP rule body (premise of a rule): Literals (i.e.
Token literal values and constants.
This class acts as an abstract base class for elements of ASP rules.
Example code for creating basic ASP programs and calling solvers and grounders.
This Translator can translate between FOL and ASP literals (without default negated literals).
 
This class provides a common interface for asp grounders.
This class is a common base class for ASP formulas that can be part of an ASP rule head.
An argument according to the ASPIC+ specification
According to Modgil and Prakken, this represents an argumentation theory (AS, KB) with - AS argumentation system (e.g.
Checks whether an argument defeats another argument
ASPIC example code that shows how to construct an ASPIC theory programmatically.
ASPIC example code that shows how to parse an ASPIC file and ask queries.
Example code for using ASPIC with first-order-logic formulas.
Exemplary code illustrating the use of the ASPIC theory generator.
This code shows the use of the ASPIC theory generator.
This code shows the use of the ASPIC theory generator.
Parses a Aspic Argumentation System out of an input text.
Several JUnit test for the package arg.aspic
For writing ASPIC argumentation theories to disk.
This class is a parser for the aspif (ASP Intermediate Format) format, the output language of gringo (https://potassco.org/clingo/).
Tests for AspifParser (parser for the the output language of gringo).
Tests the functionality of PmInconsistencyMeasure
This class defines common functionality for literals, meaning atoms or strictly negated atoms.
Translates between DLP under the answer set semantics (ASP) and NLP.
 
This class collects some common operators used in ASP terms as well as the possible function names for aggregates.
The following aggregate functions are supported by the ASP-Core-2 standard and by Tweety.
The arithmetic operators that are supported by the ASP-Core-2 standard: PLUS (+), MINUS (-), TIMES (*), DIV (/)
In addition, the following operators from Clingo and DLV are supported: MODULO (\)
The binary comparative operators that are supported by the ASP-Core-2 standard and by Tweety: LT (<), LEQ (<=), EQ (==), NEQ (!=), GT (>), GEQ (>=)
Additional special predicates of the clingo syntax that have no direct representation in the DLV or ASP-Core-2 format.
Additional special predicates of the DLV syntax that have no direct representation in the Clingo or ASP-Core-2 format.
 
 
Token literal values and constants.
Examples for parsing programs in Clingo and DLV syntax and using the respective solvers to solve them.
This class tests all important functions of the ASP-Core-2 Parser in combination with InstantiateVisitor, which is responsible for walking through the parse-tree and generating in-memory classes of the parsed ASP program.
Token Manager.
parser tree constant
 
This class models a rule in ASP.
This class provides a common interface for asp solvers.
Abstract base class for assertional axioms (concept assertions and role assertions).
A class to represent Associations in a BPMN Model
An association rule in item set mining.
Interface for algorithms mining association rules from transaction databases.
This class captures the common functionalities of description logic associative formulas (union and intersection).
This class captures the common functionalities first order associative formulas like conjunction, disjunction, etc.
This interfaces describes associative formulas like a disjunction or a conjunction.
This class provides common implementation for associative formulas that are formulas which consists of several other formulas.
This interface defines a bridge between the AssociativeFormula implementation like a concrete Disjunction and the AssociativeFormulaSupport object which adds the implementation of the common functionality.
 
This class captures the common functionalities of formulas with an associative operation like conjunction, disjunction, etc.
This class models an assumption of an ABA theory.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
The AsynchronousCloseSatSolverState.close() call is handled by the provided executor.
An atomic language construct, linked to its predicate
Gives common implementations for methods shared among atoms of different types.
An enum containing the different return values of the setPredicate() method of Atom.
This class models an atomic concept (aka concept name) in description logics.
This class models a role in description logics.
This interface captures common methods of different interpretations of the attack relation in bipolar abstract argumentation theories.
This interface is the common interface for notions of attack between two arguments.
This class models an attack between two arguments.
This notion of attack models the attack relation.
*description missing*
This class represents an attack relation for a specific set of arguments represented by an ArgumentationKnowledgeBase.
This interface is the common denominator for notions of attack between two arguments.
 
This aggregation function models the average function.
This class implements averaging semantics due to [Kern-Isberner, Thimm, KR'2010].
This class implements a consistency restorer using balanced distance minimization, see [Diss, Thimm] for details.
This class models an argument used by bipolar abstract argumentation theories.
This is the interface for a classic belief base contraction operator, ie.
This is the interface for a classic belief base expansion operator, ie.
This is the interface for a classic belief base revision operator, ie.
This class models a basic argument in structured argumentation frameworks, i.e.
This class implements a formula sampler for structured argumentation frameworks.
 
This class captures an abstract knowledge base, i.e.
Classes implementing this interface are capable of restoring consistency of inconsistent belief bases.
BeliefSet<T extends Formula,S extends Signature>
This class models a belief set, i.e.
Classes extending this abstract class are capable of testing whether a given belief set is consistent.
Classes extending this abstract class represent inconsistency measures on belief sets.
BeliefSetIterator<T extends Formula,U extends BeliefSet<T,?>>
Classes implementing this interface are able to enumerate belief sets.
BeliefSetSampler<T extends Formula,U extends BeliefSet<T,?>>
This abstract class models a random sampler for belief sets.
This abstract class encapsulates the common characteristics of a belief state for arguing agents.
This class encapsulates configuration options for generating belief states.
Implements the BFGS method to find zeros of a (multi-dimensional) function.
This class implements the BFGS algorithm for solving unconstrained optimization problems.
This class implements an example for the BfgsSolver
 
This class models a binary attack relation between two arguments.
Encapsulates common methods of mathematical functions with a two parameters.
This abstract class provides a basic implementation of a generic set of pairs to be used for preference ordering.
This class models a support between two arguments.
This class models a binary variable as a mathematical term.
This interface captures common methods of arguments and argument sets of bipolar abstract argumentation theories.
 
A category for one-class classifiers.
Implementation of the borda scoring preference aggregator
Implementation of the borda weight vector N elements are weighted from 0 to n-1 depending on their ranking function rank
This class models the bottom concept (empty concept) in description logics.
Represents the bounded sum in fuzzy logic, i.e., S(x,y)=min(x+y,1)
A class to represent Edges in a BPMN Model
A class to represent elements of a BPMN Model
A class to represent parts of a BPMN Model as a formula
 
A class to represent a BPMN Model
 
Parse a BPMN Model from the 'definitions' node of a XML representation
This class is for displaying instances of the BpmnModel class graphically
A class to represent all kinds of nodes in a BPMN Model
 
This is a helper class for parsing edges in a BPMN Model
This class implements the "Burden-based" argument semantics approach as proposed by [Amgoud, Ben-Naim.
Uses the provided function to compute absent values on access, theses values are memorized for future access to avoid further computations.
This class represents an action description for the action language C as a set of causal rules, and provides some basic functionality such as grounding.
This class is able to check if a given action description in the action language C is consistent with regards to one simple consistency requirement: The transition system described by the action description has at least one state.
A wrapper for the Cadet (https://markusrabe.github.io/cadet/) solver.
This class implements the cADF semantics by applying the Gamma Operator and checking for admissible, complete, grounded, preferred and 2-valued interpretations plus the grounded state refer to [Heyninck et al.
reasoner for admissibility in bipolar argumentation frameworks with deductive support interpretation a set of arguments is c-admissible iff it is admissible wrt.
*description missing*
 
Provides an iterator on all syntactically equivalent knowledge bases.
This attack notion models the canonical undercut relation; A is defeated by B iff claim(B) =- \neg support(A).
A wrapper for the Caqe (https://www.react.uni-saarland.de/tools/caqe/ solver.
This class generates SAT encodings for cardinality constraints.
Classes implementing this interface represent categorizer in the sense of Definition 8.10 in

Philippe Besnard and Anthony Hunter.
This class implements the "h-categorizer" argument ranking approach that was originally proposed by [Besnard, Hunter.
A category within the space of observations.
This class describes a causal knowledge base.
A basic interface representing a causal law.
This class describes a causal model.
This class is describes a causal statement, such as an interventional or counterfactual statement.
This class models a cautious argumentation agent, i.e.
This class implements the inconsistency measure I_CC from [Said Jabbour and Yue Ma and Badran Raddaoui.
Example code for CF2 semantics.
CF-Reinstatement Principle A semantics satisfies cf-reinstatement if for all extensions E it holds that: for all arguments a, if E u {a} is conflict-free and E defends a, then a is in E see: Baroni, P., and Giacomin, M.
This interface provides common methods for change operators for probabilistic argumentation.
 
This class represents an element of a choice atom.
This class is a variant of the basic ASP rule head.
a claim for an argument
an argument with a claim
test for claim based reasoners
implements claim based theory see: The Complexity Landscape of Claim-Augmented Argumentation Frameworks (Wolfgang Dvoˇr´ak Alexander Greßler Anna Rapberger StefanWoltran )
a set of claims
This class implements a simple categorizer that does an bottom-up marking of the tree; leafs are marked undefeated and an inner node is marked defeated if at least one child is marked undefeated and defeated otherwise.

The method "categorize" returns "1" if the root node is undefeated and "0" if it is defeated.
This interface models a classical formula, i.e.
This formula represents the head of an disjunctive rule which is a disjunction of literals.
Classes implementing this interface provide the means to test a training mechanism for performance.
A classifier classifies observations into categories.
This class models a clausal attack constraint
 
 
The action description language C consists of two distinct expressions: static laws and dynamic laws.
This class implements a parser for causal laws in C.
This class models a belief set on conditional logic, i.e.
skeleton of the new main method of this CLI using plugins.
Invokes Clingo (Part of the Potassco project), an ASP system that grounds and solves logic programs, and returns computed answer sets.
Test class for Clingo.
Prints ASP programs and single rules to the Clingo input format (https://potassco.org/clingo/).
Translates between propositional Conditionals and NLP.
a set of arguments S is closed under the support relation iff all arguments supported by an element of S are in S.
This class implements a parser for conditional logic.
Provides an interface to a command line based inconsistency measure analyzer
This class offers a generic wrapper for command line based SAT solvers.
Parses abstract argumentation frameworks in the CNF/Dimacs Format used for the SAT solver competition (see also http://people.sc.fsu.edu/~jburkardt/data/cnf/cnf.html).
A simple sampler for propositional belief bases.
Writes an abstract argumentation framework into a file of the CNF format.
P is coherent wrt.
A parser for the "collaboration" element in a XML tree of a BPMN model
The concept of a collector is similar to its sibling Transformer, we want to transform an AcceptanceCondition into a different structure.
This class implements a combinatorial optimization problem
Combinatorics Solver
 
This is the abstract basics class for CommandParameter Never leave identifier and description arguments for the constructor empty, they can not be changed afterwards
This class represents a comparative atom, meaning an expression of the form 't x u' where t,u are terms and x is in {<, <=, ==, !=, >, >=}.
This class compares the inference behavior of Abstract Dialectical Frameworks (AFDs) and Ranking Functions (OCFs)
This class is the superclass for all comparison criteria between two arguments in defeasible logic programming.
To select a subclass and create an instance throw a static factory method.
 
This interface represents a compatibility measure for MLNs.
Instances of this class are compilations in the sense of Definition 8 in

Philippe Besnard and Anthony Hunter.
Instances of this class represent nodes in the compilation of a knowledge base, i.e.
This class implements the approach of knowledge base compilation as proposed in

Philippe Besnard and Anthony Hunter.
This class models the complement (negation) in description logics.
Kernel SK = (A, R') for strong equivalence wrt.
This reasoner for ABA theories performs inference on the complete extensions.
Deprecated, for removal: This API element is subject to removal in a future version.
a set of arguments S is complete iff it is admissible and all arguments acceptable wrt.
a set of arguments S is complete iff it is admissible and all arguments defended by S are in S.
 
The common abstract class for concepts (also called concepts, complex concepts or concept descriptions) of description logics.
A complex logical formula can contain arguments referred as terms, this interface provides methods to substitute and exchange those terms.
Abstract base class for ComplexLogicalFormula, that are formulas which implement substitute(), exchange(), getTerms(), isGround() and isWellFormed() and therefore use terms to describe themself.
A complex number.
This class models a concept assertion in description logic, i.e.
This class implements approximate probabilistic justification of a set of queries using Monte Carlo Sampling of induced EAFs from a PEAF.
This class implements exact probabilistic justification of a set of queries by generating all possible induces EAFs from a PEAF in parallel.
Instances of this class represent condensed probability distributions, rf.
This class represents a basic conditional (B|A) with formulas A,B.
Represents a conditional structure as introduced in Section 3.5 "Conditionals in Nonmonotonic Reasoning and Belief Revision" of Gabrielle Kern-Isberner Internally it saves the data to two nested Maps.
The possible values of a conditional for a possible world
This class builds the initial kappa value list for a given conditional structure.
 
 
This notion of attack models the confident attack relation.
This notion of attack models the strong rebut relation.
 
 
 
 
 
Conflict-free Principle A semantics satisfies conflict-freeness if for all extensions E it holds that: E is conflict-free trivial property satisfied by practically all semantics see: Baroni, P., and Giacomin, M.
Deprecated, for removal: This API element is subject to removal in a future version.
reasoner for conflict-freeness in bipolar argumentation frameworks with a deductive support interpretation a set of arguments is conflict-free iff it is conflict-free in regards to the complex attacks in the framework
a set of arguments S is conflict-free iff there exists no attack between a subset of S and an element of S.
Formulas implementing this interface can be connected by using AND.
The classical conjunction of first-order logic.
This class represents a conjunction in propositional logic.
 
Classes implementing this interface are capable of testing whether a given belief base is consistent.
Provides methods for returning some model (if it exists) of a set of formulas.
This interface represents an consolidation operator for belief bases as defined in [KKI12].
A Constant represents an constant object in the world of a logical language.
This class models an abstract constant, e.g.
This class models a general constraint satisfaction problem.
Example code illustrating the contension inconsistency measure.
This class implements the contension inconsistency measure, cf.
Implements an approximation algorithm for the Contension inconsistency measure on streams.
Generates random propositional belief base with a given inconsistency measure (for the contension inconsistency measure) and of a given size.
This class implements a SAT encoding of the contension inconsistency measure, originally proposed in [Grant, Hunter.
A contradictory formula.
A contradictory formula.
 
This class provides some utility methods for converting different data types.
This class bridges the gap between Abstract Dialectical Frameworks (ADFs) and Conditional Logic (CL)
This consistency restorer determines the new probabilities of conditionals by computing the ME-distribution of each maximal consistent subset of the knowledge base, then convex combining those yielding a distribution P, and extracting the new probabilities from P.
This consistency restorer determines the new probabilities of conditionals by computing the ME-distribution of each single conditional, then convex combining those yielding a distribution P, and extracting the new probabilities from P.
For enabling cross-origin resource sharing
This class describes an counterfactual causal statement like: given phi, if v had been x then rho would be true Reference: "Argumentation-based Causal and Counterfactual Reasoning" by Lars Bengel, Lydia Blümel, Tjitze Rienstra and Matthias Thimm, published at 1st International Workshop on Argumentation for eXplainable AI (ArgXAI, co-located with COMMA ’22), September 12, 2022
This class implements the argument ranking approach of [Pu, Luo, Ranking Arguments based on Counter-Transitivity 2017].
 
 
This class implements the argument ranking approach of [Pu, Zhang, G.Luo, J.Luo.
This class represents a counting utility function, i.e.
This class implements a parser for an Action Description in the Action Description Language C from [Gelfond, Michael and Lifschitz, Vladimir: Action Languages.
This class models a c-reasoner for conditional logic.
Shows how to construct a conditional logic knowledge base programmatically and how to query it using the C-reasoner.
This class implements a credibility-based categorizer that works like the classical categorizer but dismisses arguments where the least credible agent which uttered a formula in that argument is not as least as credible as the least credible agent which uttered a formula of the parent argument.
Abstract base class for a revision process on belief bases of type TBeliefBase, it provides a method to revise one belief base with another and a method to revise a ordered list of belief bases.
Implements the credibility revision approach for ASP described in Kruempelmann et al.
interface defines a method to process the extended answer sets of the credibility revision to generate the new ELP.
This class implements a default behavior for the processing of the answer sets of the credibility logic programs.
Implements the list based method of the Revision interface by iterative calling the revision method which revise two belief bases.
Implements the revision method with two belief bases by delegating the processing to the revision method bases on an ordered list of belief bases.
Tests the revision method described in Kruempelmann et al.
 
This class is an exemplary instantiation of a revision operator based on deductive argumentation and credibilities where several parameters have been fixed: - the inner revision is a Levi revision which bases on the random kernel contraction - the transformation function is credulous - the accumulator used for deductive argumentation is the simple accumulator - the categorizer used for deductive argumentation is the credibility categorizer
This class represents belief sets for credibility-based agents multi-agent systems.
Example code on using belief operators in multi-agent settings.
This class is a wrapper for a revision for formulas of type T that is used to revise information objects.
This revision operator accepts only those pieces of information for revision where the credibility of the source is at least as high as the credibility of the agent which proves the complement.
Performs cross-validation in a classifier, i.e.
This class implements the inconsistency measure I_CSP from [Said Jabbour, Yue Ma, Badran Raddaoui, Lakhdar Sais, Yakoub Salhi.
 
This class calculates the transition system as it is described by an action description in the action language C using extended logic programming with an approach from [1].
CulpabilityMeasure<S extends Formula,T extends BeliefSet<S,?>>
Classes implementing this interface represent culpability measures, i.e.
This class extends the string list command parameter with functionality to define valid strings with regular expressions.
*description missing*
CyclicException is thrown only if the given PEAF has cyclic in the support links
Cygwin shell.
reasoner for admissibility in bipolar argumentation frameworks with deductive support interpretation a set of arguments is d-admissible iff it is admissible wrt.
This class models the dalal distance measure between possible worlds, see e.g.
Implementation of Symmetric Distance Function "Delta" as proposed in [Heyninck 2020] Adapted from class "DalalDistance" for the use of Three Valued Logic
 
 
This interface defines methods, which define how a system should decide if certain criteria are fulfilled.
 
An argument derived from an ABA theory.
Instances of this class represent arguments in the sense of Definition 3.1 in

Philippe Besnard and Anthony Hunter.
Examples for constructing deductive argumentation frameworks and computing their extensions.
This class implements a bipolar abstract argumentation theory with support in a deductive sense.
 
Extends a deductive argument by a unique identifier.
This class models the environment for agents in a game of deductive argumentation.
Shows how to construct and query a deductive knowledge base.
Instances of this class represent deductive knowledge bases, i.e.
 
This class implements the default base expansion operator, ie.
This class represents the default compatibility measure that uses a coherence measure.
This class implements a simple writer for writing condensed probability distributions.
Implements a customizable Dung theory generator.
This class models a default stream on the formulas of a given collection.
Instance of this class represent graphs with nodes of type T
Defaultification test
A simple implementation of an inconsistency listener that simply prints out each event to standard output.
This class implements a maximum entropy reasoner for probabilistic conditional logic.
This class implements the default multiple base expansion operator, ie.
This class represents a default negated literal, i.e.
Implements the default fuzzy negation x -> x-1
A default observation is a vector of double values.
This class implements a simple writer for writing probability distributions.
Computes the extensions of a default theory
Models a default rule in Reiter's default logic, see [R.
sequence of defaults
Implements a stream-based inconsistency measure on a given class of inconsistency measurement processes.
Iterates over all subsets of a given sets.
Models a default theory in Reiter's default logic, see [R.
Defeasible implementation of InferenceRule<T>
This class models a defeasible logic program (DeLP).
This class models a defeasible rule in defeasible logic programming.
This attack notion models the defeat relation; A is defeated by B iff claim(B) |- \neg support(A).
This notion of attack models the defeat relation.
This attack notion models the defeating rebuttal relation; A is defeated by B iff claim(B) |- \neg claim(A).
Deprecated, for removal: This API element is subject to removal in a future version.
not used anymore
 
Wrapping a generic answer from a reasoner in order to allow UNDECIDED in addition to the traditional YES and NO.
 
This class models a DeLP argument which comprises of a set of defeasible rules (the support) and a literal (the conclusion).
*description missing*
Shows how to parse and query a DeLP program.
This class implements a fact in defeasible logic programming which encapsulates a literal.
This class implements a parser for defeasible logic programs.
 
 
*description missing*
This reasoner performs default dialectical reasoning on some given DeLP.
*description missing*
This method is the superclass for both a strict rule and a defeasible rule in defeasible logic programming and captures their common attributes and methods.
Web service for defeasible logic programming.
Derivation<T extends Rule<?,?>>
This class models a derivation, i.e.
This class implements the family of "Measures of the Degree of Inconsistency" from [Mu,Liu,Jin, Bell.
Example code illustrating the Df inconsistency measure.
This class implements the d-hit inconsistency measure from [Grant, Hunter.
This class presents a sat-encoding-based implementation of the hit-distance measure of [Grant and Hunter, “Analysing inconsistent information using distance-based measures” Int.
This class implements a node of a dialectical tree from DeLP.
 
Objects of this class represent traces of dialogue in an argumentation game, ie.
This class models a difference between two terms.
Generic class for Dimacs-based MaxSAT solvers.
Parser a file in Dimacs format into a PlBeliefSet.
Interface for SAT solvers which work on the Dimacs format.
This attack notion models the direct defeat relation; A is defeated by B iff there is c in support(A) with claim(B) |- \neg c.
Instances of this class represent directed edges.
This class implements a direct protocol for argumentation games.
Creates direct game protocols.
Computes a restricted AF by only considering relevant arguments to a query.
Directionality Principle A semantics satisfies directionality if for every unattacked set U in a dung theory F it holds that: The extensions of F restricted to U are equal to the extensions of F intersected with U see: Baroni, P., and Giacomin, M.
Test runtime of module-based vs.
This attack notion models the direct undercut relation; A is defeated by B iff there is c in support(A) with claim(B) == \neg c.
Interface for directed hypergraph
This class implements the "Discussion-based" argument semantics approach as proposed by [Amgoud, Ben-Naim.
Formulas implementing this interface can be connected using OR.
The classical disjunction of first-order logic.
This class represents a disjunction in propositional logic.
 
This class models the distance minimization inconsistency measure as proposed in [Thimm,UAI,2009], extended by the use of different p-norms.
This consistency restorer uses the distance minimization inconsistency measure to restore consistency.
A pair <P,V> is a division of AAF G w.r.t.
Example code for working with divisions.
The common abstract class for axioms of the description logic ALC.
This class models a knowledge base for description logics.
Examples for using the description logic syntax classes and parser.
This class models an interpretation for description logics.
This class implements a parser for the description logic ALC (attributive concept language with complements).
JUnit test class for the description logics parser.
JUnit Test class for NaiveDLReasoner.
This class models a description logic signature.
Wrapper class for the DLV answer set solver command line utility.
Test class for DLV.
Prints ASP programs and single rules to the DLV input format (http://www.dlvsystem.com/html/DLV_User_Manual.html).
This class implements the d-max inconsistency measure from [Grant, Hunter.
This class presents a sat-encoding-based implementation of the max-distance measure of [Grant and Hunter, “Analysing inconsistent information using distance-based measures” Int.
A category for multi-class classification using a double as identifier.
DrasticDistance<T extends Interpretation<B,S>,B extends BeliefBase,S extends Formula>
This class models the drastic distance measure between interpretations, see [Grant, Hunter.
*description missing*
This class models the drastic inconsistency measure.
This class implements the d-sum inconsistency measure from [Grant, Hunter.
Example code illustrating the distance-based inconsistency measures DSum, DMax and DHit.
This class presents a sat-encoding-based implementation of the sum-distance measure of [Grant and Hunter, “Analysing incThis measure seeks an interpretation I such that the the sum of the distances between every formula of the knowledge base and I is minimal.
This class models a signature as two sets of formulas.
A dummy agent is an agent that cannot act.
Generates dummy lottery agents.
Audience agents (do nothing) for argumentation games.
This interface captures common methods of arguments and attacks of abstract argumentation theories.
*description missing*
*description missing*
*description missing*
*description missing*
*description missing*
*description missing*
*description missing*
This class captures the signature of a Dung theory, i.e.
This class implements an abstract argumentation theory in the sense of Dung.
This class lists some parameters for Dung theory generation.
Class implementing this interface provide the capability to generate Dung theories.
Example code for generating dung theories and exporting them to apx format.
This class represents a specialization of graph plotters used to visualize argumentation frameworks, also called @see org.tweetyproject.arg.dung.syntax.DungTheory.
This class summarizes some examples, showcasing the usage of the DungTheoryPlotter to visualize argumentation frameworks , also called DungTheory.
Creates an aggregator for dynamic veto scoring
A dynamic law in C has the form "caused F if G after U" where F is a propositional formula over the set of fluent names (called headFormula) G is a propositional formula over the set of fluent names (called ifFormula) U is a propositional formula over the set of fluent names and the set of action names (called afterFormula)
Creates an dynamic aggregator with plurality scoring
This interface is meant to be used for the dynamic aggregation of some generic preference orders
This Demo-class provides a basic implementation similar to the ScoringPreferenceAggregator but dynamic aggregation instead of static
Creates an dynamic aggregator for veto scoring
 
This class implements an abstract argumentation theory in the sense of Evidential Argumentation Frameworks (EAF).
converts EAF to DAF
 
Evidential attack used for PEAF and EAF
Edge<T extends Node>
Instances of this class represent abstract edges.
The EdgeList writer is a utility class for testing purposes to write networkx compatible EdgeList file format.
Implements the EEE approach ("exhaustively enumerate extensions") to determine the set of acceptable arguments of an AF, cf.
Invokes E (http://eprover.org), an automated theorem prover for first-order logic, and returns its results.
This class implements an element for a combinatorial problem.
This class implements the base revision operator for extended logic programs as introduced in [KKI12].
This comparator imposes a total order on the set of extended logic programs by use of the lexicographical order given as follows: A program A is less than a program B iff the smallest rule of A is smaller than the smallest rule of B or if both are equal if the second smallest rule of A is smaller than the second smallest rule of B and so on.
This class implements the empty criterion to compare two arguments.
A class to represent end events in a BPMN Model
Parse end events of a BPMN model
Class representing an entity with an underlying hidden argumentation framework.
The entropy function.
The entropy norm.
This class is responsible for dilating a specified original abstract argumentation framework by adding new arguments and new attacks, while conserving the original framwork.
This generator generators all possible Dung argumentation theories.
 
This interface models an environment for agents, i.e.
Episode<S extends State,A extends Action>
This class models an episode in MPDs, i.e.
This class models an equality predicate, meaning a predicate of arity 2 that maps to the identity relation.
tests equality
This class represent an equation of two terms.
This interface defines methods to analyze the equivalence of two objects.
The equivalence of first-order logic.
This class models equivalence of propositional logic.
 
This class models an equivalence axiom, also known as "general concept inclusion" (GCU), meaning an expression of the form "C is a subset of or equal to D" where C and D are concepts.
This class is responsible for classifying abstract argumentation frameworks due to their equivalence
This class summarizes example showing how to use the EquivalenceClassifier
This class represents an example generator.
This class represents a summary of examples to show the use of EquivalenceCompExFinder.
An abstract kernel for strong equivalence in abstract argumentation frameworks
This interface defines methods to generate equivalent theories.
This class implements the Eta-inconsistency measure, cf.
The evaluate rule tries to evaluate the kappa values by using logical constraints, therefore the KappaTerm evaluate() methods are called.
This class represents an implementation of example 4, 5 and 6 from the paper [Heyninck et al.
An inconsistency listener that is apt for doing evaluations on the performance of an inconsistency measure.
 
A class to represent events of all kinds in a BPMN Model
Possible types of events in a BPMN model
Examples for evidential argumentation frameworks.
More examples for evidential argumentation frameworks.
More examples for evidential argumentation frameworks.
This class implements a bipolar abstract argumentation theory with support in an evidential sense.
 
This class implements exact probabilistic justification of a set of queries by generating all possible induces EAfs from a PEAF.
ExactPEAFInducer generates all possible EAFs that can be generated from a PEAF.
Visualize inconsistency analysis for some BPMN models
This class can be used to find example dung theories that produce the same set of extensions wrt to one semantics, but different extensions wrt to another semantics
example to show the use of the ExampleFinder class
Generates an overview of example classes and resources in the workspace with HTML formatting.
Iterates through all interpretations except the ones equal to or more specific than the provided ones.
 
Iterates through all two-valued(!) interpretations except the ones equal to or more specific than the provided ones.
 
The exclusive disjunction (XOR) in first-order logic.
This class represents an exclusive disjunction (XOR) in propositional logic.
 
A class to represent exclusive gateways in a BPMN Model
Parse exclusive gateways in a BPMN model
An executable is an action an agent performs within an environment.
This class packs a Dung theory into an executable object.
This class packs an extension into an executable object.
This class packs a set of formulas into an executable object.
Encapsulates the state of a query execution.
This class models an existential restriction in description logics, i.e.
Exists-quantified first-order logic formula.
This class represents existential quantification for boolean formulas.
This class represents an exponential expression by "e".
 
This class can be used to find example dung theories that produce the same set of extensions wrt to two semantics, but different extensions wrt to another semantics
example to show the use of the ExtendedExampleFinder class
This class models a (possible) extension of a Dung theory, i.e.
An extension of a default theory, i.e.
 
 
Example on how to use the OrderingSemanticsReasoner.
Reasoner using ranking semantics.
This enum lists ordering semantics.
Implements the forgetting-based inconsistency measure from [Besnard.
Some examples from [Besnard.
This generator receives a list of files containing Dung theories and returns those step by step.
This enum lists all supported file formats.
This parameter holds a file-list of possible arguments
This class models the plugin for first order logics used in the tweety cli Note: Currently FOL-files MUST BE named after the pattern "*.fologic" Very early state, not finished or debugged yet.
FixedPolicy<S extends State,A extends Action>
A fixed policy for MDPs, i.e., a simple map from states to actions.
Fixes the already assigned true/false values.
Syntactically rewrites the acceptance condition s.t.
This class models a reasoner over ABA formulae.
This class encapsulates a float as a term.
This class models an float variable as a mathematical term.
An action is a truth-valued function on the set of action names, which is denoted by the set of actions which are mapped to 'true'.
This class represents an action name.
An atom in first-order logic, i.e.
This class models a first-order knowledge base, i.e.
Some examples for using FolParser and provers.
This class represents a fluent name.
The common abstract class for formulas of first-order logic.
Implements RuleFormulaGenerator for first order logic.
This class implements a parser for first-order logic.
JUnit Test class for FolParser.
A Translator between the FOL and propositonal logic and vice versa.
Abstract FOL Prover to be implemented by concrete solvers.
This class captures the signature of a specific first-order language.
Prints out single first-order logic formulas and full knowledge bases.
For-All-quantified first-order logic formula.
This class represents universal quantification for boolean formulas.
A formula is a basic language construct.
This abstract class models a sampler for formulas.
This interface models a stream on formulas.
P is founded wrt.
This class models a four-valued interpretation for propositional logic Formulas are interpreted using completions Every atom is assigned one of the four truth values: TRUE, FALSE, UNDECIDED, INCONSISTENT
 
This class iterates over all 4-valued interpretations of a given signature.
An example for the FP-Growth algorithm
Implements the FP-Growth Algorithm for frequent pattern mining, cf.
This is the function 1-\sum_i (1-x_i/i) used e.g in [Mu,Liu,Jin, Bell.
Instances of this class represent fractions of two terms.
The function 1/x.
Interface for algorithms mining frequent patterns from transaction databases.
Implements the an FP-Tree for the FP-Growth Algorithm for frequent pattern mining, cf.
Implements the Fudge approach to determine the set of acceptable arguments of an AF wrt.
A functional term in a logic language, i.e.
Instances of this class represent a functional term on some inner term.
An abstract class as superclass for two different ranking/leveling functions used to rank elements from preference orders
A functor for logic language, i.e.
This measure implements the approach presented in [Thimm, Measuring Inconsistency with Many-Valued Logics.
 
A fuzzy interpretation for propositional logic.
Example code illustrating fuzzy logic-based inconsistency measures.
Represents a fuzzy negation, i.e., a generalization of a logical negation on values in [0,1].
Classes implementing this interface represent protocols for games in the game theoretic meaning.
This class implements a game simulator.
A class to represent gateways of all kinds in a BPMN Model
Possible types of gateways in a BPMN model
This is an abstract generalization over non-flat ABA reasoners.
Main factory for retrieving reasoners for aba.
An enumeration of all available inconsistency measures.
This abstract class is the common ancestor for semantical approaches to ranking, i.e.
generalization of CSP
 
 
Uses the generalized ME-model of a knowledge base to repair it, cf.
This class implements a generalized maximum entropy reasoner for probabilistic conditional logic as proposed in [Potyka, Thimm, 2014] which also works for inconsistent belief sets.
This class implements the generalized specificity criterion used to compare two arguments.
This class is represents a general math exception;
Similar to the ThreeValuedBitSet but with arbitrary values allowed Can be used for 4-valued interpretations but also for anything above that!
A wrapper for the GhostQ (https://www.wklieber.com/ghostq/) solver.
Provides a Java binding to the Glpk solver (https://www.gnu.org/software/glpk).
This class implements an example for the Glpk Solver
This class implements the gradient descent method to find an optimum.
Implements the gradient descent method to find zeros of a (multi-dimensional) function.
This class implements an example for the Gradient Descent Solver
Graph<T extends Node>
Common interface for graphs with nodes of type T
Example that shows how to construct graphs programmatically.
Another example that shows how to construct graphs programmatically.
GraphPlotter<T extends Node,S extends GeneralEdge<T>>
A generic class for plotting graphs
 
This abstract class contains some auxiliary methods for working with graphs.
 
A grid-search approach for learning parameters.
Invokes Gringo (Part of the Potassco project), an ASP system that grounds logic programs.
Computes the preferred extension of the given PEAF
Generates new arguing agents for a grounded game.
Generates grounded games.
This class implements a round robin protocol for the grounded game.
Creates protocols for a grounded game.
This multi-agent system models a grounded dialogue game between two agents.
The factions of agents in this game.
Generates agents of type T1.
Generates agents of type T2.
Generates agents of type T3.
The grounded game utility function u_a^g.
Kernel SK = (A, R') for strong equivalence wrt.
the grounded extension of bbase is the least fixed point of the characteristic function.
the grounded extension of bbase is the least fixed point of the characteristic function.
Shows how a simulation of a multi-agent system can be set up.
Shows how a simulation of a multi-agent system can be set up.
Shows how a simulation of a multi-agent system can be set up.
 
 
This is a common interface for grounding constraints, which have to be met by a grounder when calculating possible applications of constants to variables.
This class parses a list of grounding requirements of the form REQUIREMENT ("," REQUIREMENT)*
This class holds common grounding functionality for causal theories using first-order formulas.
Deprecated, for removal: This API element is subject to removal in a future version.
This class is a wrapper for the Gurobi optimizer (https://www.gurobi.com).
test for gurobi
This class implements the h-categorizer from

Philippe Besnard and Anthony Hunter.
The Herbrand base is the set of all possible ground atoms of some given first-order logic.
A Herbrand interpretation is an interpretation for a first-order signature, stating all ground atoms that are true in the interpretation.
This class implements a gradient descent involving Hessian correction for solving unconstrained optimization problems.
Implements the hessiane/gradient descent method to find zeros of a (multi-dimensional) function.
This class implements an example for the Hessian Gradient Solver
This class represents a holds query in the action query language S.
This class implements the Hitting Set inconsistency measure as proposed in [Thimm, 2014, in preparation].
Implements an approximation algorithm for the Hs inconsistency measure on streams.
Generates random propositional belief base with a given inconsistency measure (for the Hs inconsistency measure) and of a given size.
This class implements a SAT encoding of the hitting set inconsistency measure, originally proposed in [Thimm.
Instances of this class represent abstract edges.
HyperGraph<T extends Node>
This class implements a simple directed hypergraph
example for a hypergraph
Implements the IAQ approach ("iterative acceptability queries") to determine the set of acceptable arguments of an AF, cf.
Parses abstract argumentation frameworks in the ICCMA 23 format (see also https://iccma2023.github.io/rules.html#input-format).
Writes an abstract argumentation framework into a file of the ICCMA23 format, see https://iccma2023.github.io/rules.html#input-format.

NOTE: this format is a slight variation of the CNF format (see CnfWriter)
Example code for the "iceberg" inconsistency measures as described in [De Bona, Hunter.
This class implements the inconsistency measures proposed in [De Bona, Hunter.
A consequence operation returns parts of knowledge bases.
This reasoner for ABA theories performs inference on the ideal extension.
This class represents an comparator, which defines if 2 argumentation frameworks are equivalent, by comparing if they are equal.
The "adjunction invariance" postulate for inconsistency measures: The set notation of knowledge bases should be equivalent to the conjunction of its formulas in terms of inconsistency values.
The "attenuation" postulate for inconsistency measures: Minimal inconsistent sets of smaller size should have a larger inconsistency value.
I-Maximality Principle A semantics satisfies I-Maximality iff for all pairs of extensions E1, E2 it holds that: if E1 is a subset of E2, then E1 = E2 see: Baroni, P., and Giacomin, M.
The "consistency" postulate for inconsistency measures: Consistent knowledge bases receive the minimal inconsistency value (0) and all inconsistent knowledge bases have strictly positive inconsistency values.
The "contradiction" postulate for inconsistency measures: A knowledge base is maximally inconsistent if all non-empty subsets are inconsistent.
The "dominance" postulate for inconsistency measures: Substituting a consistent formula by a weaker formula should not increase the inconsistency value.
The "equal conflict" postulate for inconsistency measures: Minimal inconsistent subsets of the same size should have the same inconsistency value.
The "exchange" postulate for inconsistency measures: Exchanging consistent parts of a knowledge base with equivalent ones should not change the inconsistency value.
The "free-formula dilution" postulate for inconsistency measures: Removing a formula not participating in any minimal inconsistent set does not make the inconsistency value larger.
The "free-formula independence" postulate for inconsistency measures: Removing a formula not participating in any minimal inconsistent set (= a free formula) does not change the inconsistency value.
The "irrelevance of syntax" postulate for inconsistency measures: Knowledge bases with pairwise equivalent formulas should receive the same inconsistency value.
The "MI-normalization" postulate for inconsistency measures: The inconsistency value of any minimal inconsistent subset is 1.
The "MI-separability" postulate for inconsistency measures: The sum of inconsistency values of two knowledge bases with non-interfering sets of minimal inconsistent subsets should be the same as the inconsistency value of their union.
The "monotony" postulate for inconsistency measures: Adding information to a belief base cannot decrease the inconsistency value.
The "normalization" postulate for inconsistency measures: The inconsistency value is always in the unit interval [0,1], making it possible to compare inconsistency values for knowledge bases of different sizes.
The "penalty" postulate for inconsistency measures: Adding a formula that participates in an inconsistency (i.e.
The implication of first-order logic.
This class models the implication of propositional logic.
 
An abstract postulate for inconsistency measures in propositional logic; the ancestor of all concrete postulates.
Example code illustrating automatic postulate evaluation of inconsistency measures.
Implementation of the algorithm for learning (grounded) labelings from with some improvements: Riveret, Régis, and Guido Governatori.
The "safe-formula independence" postulate for inconsistency measures: Removing a safe formula (i.e.
The "super-additivity" postulate for inconsistency measures: The sum of the inconsistency values of two disjoint knowledge bases is not larger than the inconsistency value of the joint knowledge base.
A weaker variant of the "dominance" postulate using prime implicates, proposed in [Jabbour et al.
This interface models an incision function for kernel contraction, ie a function that incises each of the kernel sets of some set.
A class to represent inclusive gateways in a BPMN Model
Parse inclusive gateways in a BPMN model
incomlete argumentation framework class
example of a problem for an incomplete reasoner
implementation of incomplete argumentation frameworks
*description missing*
Listener interface for listeners of stream-based inconsistency measures.
*description missing*
Classes implementing this interface represent inconsistency measures on belief bases.
Example code for using InconsistencyMeasureEvaluator for comparing inconsistency measure implementations.
This class provides functionality to quickly load or generate sample datasets and to use them to compare the results and performances of different inconsistency measure implementations.
Main factory for retrieving inconsistency measures for propositional logic.
An enumeration of all available inconsistency measures.
The actual process of an inconsistency measure on streams.
Inconsistency measurement service.
This class summarizes the results of computing inconsistency values for some collection of knowledge bases using some set of inconsistency measures, including computation times and some statistics.
This class represents the results the result of a call to an inconsistency measure with a knowledge base, i.e.
Status of an InconsistencyMeasureResult: OK means that an inconsistency value has been computed.
 
An event that is thrown when an inconsistency value has been updated.
*description missing*
Iterates over all subsets of a given set.
 
This class models an indecision operator for 3-valued propositional logic as proposed in [Heyninck 2020] Indecision(a) is true, if formula a is undecided Indecision(a) is false, if formula a is true or false Adapted from the class "Negation"
This class implements methods for computing conditional independence of sets of arguments in abstract argumentation Rienstra, Tjitze, et al.
Example usage of the Independence class example theory taken from: Rienstra, Tjitze, et al.
 
This class represents an indicator utility function, i.e.
This class models an individual in description logic, also known as an object.
This class is responsible for the representation of an Argument that was induced by a CausalKnowledgeBase Reference: "Argumentation-based Causal and Counterfactual Reasoning" by Lars Bengel, Lydia Blümel, Tjitze Rienstra and Matthias Thimm, published at 1st International Workshop on Argumentation for eXplainable AI (ArgXAI, co-located with COMMA ’22), September 12, 2022
This class describes an abstract argumentation framework that was induced by a CausalKnowledgeBase Reference "Argumentation-based Causal and Counterfactual Reasoning" by Lars Bengel, Lydia Blümel, Tjitze Rienstra and Matthias Thimm, published at 1st International Workshop on Argumentation for eXplainable AI (ArgXAI, co-located with COMMA ’22), September 12, 2022
This class is an intermediate representation of EAFs that are induced from a PEAF.
This class models an inequality predicate, meaning a predicate of arity 2 that maps to the complement of the identity relation.
This class models an inequation of two terms.
Enum constants for the two classical inference models of skeptical inference (assess a formula as true iff it is contained in every model) and credulous inference (assess a formula as true iff it is contained in some model).
This class models an inference rule from an ABA theory.
This stands for an inference rule or for a premise if premises has length 0.
This class represents a formula annotated with the source of the formula.
Implementation of the input labeling (here called example) as an extension of normal labeling i.e.
Irrelevance of Necessarily Rejected Arguments (INRA) Principle A semantics s satisfies INRA if for every AF F it holds that: for every argument a in F, if every s-extension attacks a, then s(F) = s(F\{a}) i.e if an argument is attacked by every extension, then it does not influence the computation of extensions and can be ignored see: Cramer, M., and van der Torre, L.
Instances of this class represent assignenment of true instances for a given predicate wrt.
This visitor iterates over the AST generated by ASPParser and allocates classes representing the different parts of an ASP program or source file, meaning rules, literals, terms, answer sets, etc.
*description missing*
This parameter holds a number-interval of possible arguments
This class encapsulates an integer as a term.
This class models an integer variable as a mathematical term.
A class to represent intermediate events of all kinds in a BPMN Model
Parse intermediate events in a BPMN model
Interface for classes enumerating (Craig) interpolants.
This class represents a three-valued interpretation of an Abstract Dialectical Framework (ADF).
An interpretation for some logical language.
 
Classes implementing this interface represent distance functions between two interpretations.
Creates all possible interpretations while respecting the order of the given arguments.
An iterator over interpretations.
 
Performs further processing on interpretations, e.g.
InterpretationSet<T extends Formula,B extends BeliefBase,S extends Formula>
This class models an interpretation that is a set of some formula and as such implements the java.util.Collection interface.
Deprecated.
Was written for failed experiments and is not maintained anymore.
This class models an intersection in description logics.
Interval<S extends Number>
This class contains a set of closed set (interval) of possible numbers
This class describes an interventional causal statement like: given phi, if v would be x then rho would be true Reference: "Argumentation-based Causal and Counterfactual Reasoning" by Lars Bengel, Lydia Blümel, Tjitze Rienstra and Matthias Thimm, published at 1st International Workshop on Argumentation for eXplainable AI (ArgXAI, co-located with COMMA ’22), September 12, 2022
Formulas implementing this interface have a complement
P is involutary wrt.
This class implements the inconsistency measure I_CSP from [Said Jabbour.
This generator generators all possible Dung argumentation theories (modulo graph isomorphism).
This reasoner provides is an implementation of the "Iterative Successive Substitution Algorithm" from [Marco Correia and Jorge Cruz and João Leite.
This class implements the argument ranking approach of [Grossi, Modgil.
Example code for using the iterated graded semantics from [Grossi, Modgil.
implements the Iterates local search algorithm for combinatorial problems
implements the Iterates local search algorithm for optimization problems
This class implements an example for Tabu search.
This MLN reasoner takes another MLN reasoner and performs several iterations with this one and takes the average result as result.
Determines utilities iteratively.
 
*description missing*
P is justifiable wrt.
 
This class represents a minimum, its elements are KappaTerm instances although in c-representation this are sums of Kappas KappaSum.
This constructs represents a sum of kappa values (or terms).
This interface defines a kappa term, that can be evaluated, it can return its value, which is -1 as long as the kappa-term cannot be evaluated and it can return a value for that we know that the kappa-term value is greatar or equal to that value.
Represents a Kappa-Value for the c-revision, it contains two KappaMin instances, both KappaValue and KappaMin implement the KappaTerm interface.
 
 
This class implements kernel contraction for belief bases [Hansson:2001].
Classes implementing this interface are able to provide kernels (=minimal proofs).
This class implements a KnapSack problem
example for KnapSack via GenOpt
Class implementing an example for a TSP on a cartesian fully connected graph
example for KnaSack via SimAn
Class implementing an example for a TSP on a cartesian fully connected graph
example of KnapSack via Tabu Search
This class describes a knowledge base.
A parser for the input format described at https://www.cs.helsinki.fi/group/coreo/k++adf/ Since the input format is only described informally, we assume that each argument has to be defined before it can be used in some way, e.g.
 
 
This class models a Kripke model, i.e.
Creates AAFs with a complex structure for tasks related to skeptical reasoning wrt.
Example code for generating a lot of KWT graphs.
This class models a labeling of an abstract argumentation framework, i.e.
This class implements a (naive) Langrange solver for optimization problems.

This solver only considers optimization problems without inequations.
This class implements an example for the Lagrange Solver.
This class implements an example for a problem solved by the lagrange solver.
A class to represent lanes in a BPMN Model
Parse lanes in a BPMN model
Parse a set of lanes in a BPMN model
A language exception is thrown if something illegal is tried in a language like setting the arity of a propositional predicate > zero.
 
Fixes the two valued assignments and tries to find a two valued assignment for at least one of the undecided ones.
 
This class models comparable element ranking by representing the acceptability of comparable elements in a graph-based structure.
Lazily computes missing values.
This class represents an argument in ldo.
This class implements an argumentation lottery based on the logic of dialectical outcomes, i.e.
This class captures the common functionalities of formulas with an associative operation like conjunction, disjunction, etc.
*description missing*
This class represents a conjunction in ldo logic.
*description missing*
This class represents a disjunction in ldo logic.
This abstract class specifies the general methods of all Ldo-formulas (LDO - Logic of dialectical outcomes, cf.
*description missing*
*description missing*
This class models an LDO interpretation, i.e., a pair of an argumentation framework and (possibly) an extension.
This class models classical negation of ldo logic.
Creates a relational formula, i.e.
A utility function that maps LDO formulas to utilities
Argument Learning example.
This class is meant to provide leveling functions to given preference orders and vice versa.
This class implements the Levi identity for revision, ie.
This class implements the Levi identity for multiple revision, ie.
This comparator compares two vectors of double values according to the lexicographic ordering.
This comparator compares tuples of integers according to the lexicographic ordering as described in [Cayrol, Lagasquie-Schiex.
Deprecated.
 
 
 
 
 
 
 
This class extends the default argumentation reasoner to the reasoning about literals in the set of arguments constructible from an extended logic program p.
 
Instances of this class represent application of the logarithm function on some term.
This class provides some String constants for logical symbols and allows to modify them at runtime.
LogicProgram<C extends Formula,P extends Formula,T extends Rule<?,?>>
An interface for a logic program, which is a set of rules.
This interface captures the common functionalities of formulas, sorts and terms.
This abstract class captures the common functionalities of both formulas and terms.
This class models the environment for agents in argumentation games with lotteries.
Shows how a simulation of a multi-agent system can be set up.
Main class for empirical evaluation in [Hunter, Thimm.
Example code for working with lotteries in probabilistic abstract argumentation.
Generates lottery games.
This multi-agent system models a lottery dialogue game between a lottery agent and a dummy agent
This class models an approximation from below to the distance minimization inconsistency measure as proposed in [Thimm,UAI,2009], see [PhD thesis, Thimm].
This class implements a wrapper to the lpsolve binary for mixed integer linear programming.
This class implements an example for the Genetic LpSolver.
Represents the Lukasiewicz-norm in fuzzy logic, i.e., T(x,y)=max(x+y-1,0)
This class models the I_M inconsistency measure from e.g.
Example code illustrating the Ma inconsistency measure.
The Manhattan norm.
This class provides some utility functions for maps.
Implements a MUs enumerator based on MARCO (http://sun.iwu.edu/~mliffito/marco/).
A class to describe markings (i.e.
A class to describe markings of a Petri net.
This class models a Markov Decision Process (MDP, for fixed starting and terminal states), which can be used to represent reinforcement learning scenarios.
Instances of this class represent Markov Logic Networks [Domingos et.
A class to perform a stochastic walk on a reachability graph based on a probability function on that graph
This class contains some useful math tools.
 
This class models a matrix of terms.
This aggregation function models the maximum function.
Implementation of example Grippe (flu) from lecture Commonsense Reasoning in summer term 2020, chapter 4, slide 204
The maximum function.
This class models the maximum of two terms.
Represents the maximum-conorm in fuzzy logic, i.e., S(x,y)=max(x,y)
This consistency restorer uses the idea of the upper approximative distance minimization inconsistency measure to compute a ME-probability distribution and adjust the probabilities of the conditionals accordingly.
The Maximum norm.
Illustrates the use of MaxSAT solvers.
Provides a generic class for implementing MaxSAT solvers, i.e.
This class implements the approach of [Meriem Ammoura, Badran Raddaoui, Yakoub Salhi, Brahim Oukacha.
Example code illustrating the MCSC inconsistency measure.
Illustrates the use of Markov Decision Processes using a vacuum cleaner example.
This class implements the mean distance culpability measure, see [PhD thesis, Thimm].
 
A class to represent message objects in a BPMN Model
A class to represent edges of the message flow in a BPMN Model
Parse an edge of the message flow in a BPMN model
This class models the MI^C inconsistency measure.
This class models the MI inconsistency measure.
Implements a MUs enumerator based on MIMUS (http://www.cs.qub.ac.uk/~kmcareavey01/mimus.html).
This aggregation function models the minimum function.
Example code illustrating the use of MUS enumerators.
 
This class models the minimal violation inconsistency measure for the 2-norm.
Repairs a probabilistic belief base by taking the probabilities from the probability function that minimizes the "minimal violation inconsistency measure" with respect to the euclidean norm.
Repairs a probabilistic belief base by taking the probabilities from the probability function that minimizes the "minimal violation inconsistency measure" with respect to the euclidean norm.
Repairs a probabilistic belief base by taking the probabilities from the probability function that minimizes the "minimal violation inconsistency measure" with respect to the euclidean norm.
This class provides a general implementation for the minimal violation inconsistency measure, cf.
 
This class models the minimum of two terms.
This approach to consistency restoration follows the approach proposed in [Thimm, DKB, 2011].
Represents the minimum-norm in fuzzy logic, i.e., T(x,y)=min(x,y)
Repairs a probabilistic belief base by taking the probabilities from the probability function that minimizes the "minimum violation inconsistency measure".
 
 
 
Generates random propositional belief base with a given inconsistency measure (for the MI inconsistency measure) and of a given size.
This class models a modal knowledge base, i.e.
Invokes MleanCoP (http://www.leancop.de/mleancop/), a compact automated theorem prover for modal first-order logic based on the clausal connection calculus.
JUnit Test class for the MleanCoP reasoner.
Prints single FOL and modal formulas to the MleanCoP format:

Negation: '~'
Conjunction: ','
Disjunction: ';'
Implication: '=>'
Equivalence: '<=>'
Universal quantifier: 'all X:'
Existential quantifier: 'ex X:'
Modal box operator (Necessity): '#'
Modal diamond operator (Possibility): '*'
Some examples for testing ModalParser and NaiveModalReasoner.
More examples for testing ModalParser and ModalReasoner.
This class models a modal formula, i.e.
Modified version of HerbrandBase that allows for modal formulas.
Modified version of HerbrandInterpretation that allows for modal formulas.
Shows how MLNs can be constructed programmatically and shows how coherence measures can be used.
Gives further examples on how MLNs can be constructed programmatically and how coherence measures can be used.
Instances of this class represent first-order formulas with a weight.
This class implements a parser for modal logic.
JUnit Test class for ModalParser.
JUnit Test class for NaiveModalReasoner.
 
Helper class providing methods for more efficient computation of models for specific formulae
 
ModelProvider<S extends Formula,B extends BeliefBase,T extends Interpretation<B,S>>
Instances of this interface model reasoners that determine the (selected) models for a given set of formulas.
Deprecated, for removal: This API element is subject to removal in a future version.
Modularization Principle A semantics s satisfies modularization iff for every AF F we have: if E1 is a s-extension of F and E2 is a s-extension of the E1-reduct of F, then (E1 u E2) is a s-extension of F see: Baumann et.
Slightly optimised reasoner for ASPIC.
This class implements a monotone global maxichoise selection function for remainder sets of extended logic programs as introduced in [KKI12].
This class implements the Monte Carlo algorithm for estimating probabilities of extensions in probabilistic argumentation frameworks from [Li, Oren, Norman.
Takes the arguments with the most bipolar parents.
Returns the arguments with the most complex acceptance condition, according to their logical complexity.
A multi-agent system is a collection of agents with some environment.
 
Trains a standard multi-class RBF support vector machine.
This is the interface for a classic multiple belief base contraction operator, ie.
This is the interface for a classic multiple belief base expansion operator, ie.
This is the interface for a classic multiple belief base revision operator, ie.
This class represents a multiple indicator utility function, i.e.
This class implements a multiple selective revision operator following [Kruempelmann:2011,Ferme:1999].
This interface represents a multiple transformation function for selective revision [Kruempelmann:2011,Ferme:1999].
Interface for classes enumerating MUSes (minimal unsatisfiable sets) and MCSs (maximal consistent sets).
Example code illustrating the use of MUS enumerators.
This class implements the "MUS-variable based inconsistency measure" proposed in [Xiao,Ma.
Naive reasoner for the description logic ALC.
This class represents the naive transformation function for literals as introduced in [1].
 
A simple approach to compute minimal inconsistent subsets and maximal consistent subsets by exhaustive search.
Naive classical inference for quantified boolean formulas (checks all interpretations for satisfiability).
Deprecated, for removal: This API element is subject to removal in a future version.
Naivety Principle A semantics satisfies naivety if for all extensions E it holds that: E is conflict-free and maximal w.r.t set inclusion see: TODO
Verifies if a given interpretation is conflict-free and maximal, i.e.
An action in a Markov Decision Process that is solely characterized through its name.
This class inherits PEAFTheory to store additional information regarding the arguments inserted
A state in a Markov Decision Process that is solely characterized through its name.
Experimental lingeling binding
 
 
Default shell
This class implements an inconsistency measure based on "n-consistency" proposed in [Doder,Raskovic,Markovic,Ognjanovic.
This class represents a necessarily query in the action query language S.
This class models the necessity modality.
Examples for necessity argumentation frameworks.
This class implements a bipolar abstract argumentation framework with necessities.
 
Negation<T extends Formula>
 
The classical negation of first-order logic.
This class models classical negation of propositional logic.
 
NestedLogicProramException encapsulates those LanugageException that occur in nested logic programs.
P is neutral wrt.
This class implements the Newton method for finding zeros of a function.
Wrapper for the PossibleWorld providing better representation mechanisms, it knows all the possible propositions (the signature) and therefore provides a complete representation that maps a boolean to the Proposition.
*description missing*
Implementation of the MaxSAT algorithm from: Niskanen, Andreas, Johannes Wallner, and Matti Järvisalo.
A default negation of a first order formula, nested logic programs only allow not quantified formulas.
A nested logic program
A rule of a nested logic program.
 
an interface for a general Node
 
This class represents an exception, thrown if no example was found.
This exception is thrown when a non-differentiable term is attempted to be differentiated.
*description missing*
A norm for vector spaces.
This class models the normalized distance minimization inconsistency measure, see [PhD thesis, Thimm].
This class models a normalized approximation from below to the distance minimization inconsistency measure as proposed in [Thimm,UAI,2009], see [PhD thesis, Thimm].
This class models the normalized MI^C inconsistency measure, see [PhD thesis, Thimm].
This class models the normalized MI inconsistency measure, see [PhD thesis, Thimm].
This class models a normalized approximation from above to the distance minimization inconsistency measure as proposed in [Thimm,UAI,2009], see [PhD thesis, Thimm].
NumberSet<S extends Number>
This empty interface is only for the Interval- and IntervalSet-classes
This is a term representing an integer number it is used to distinguish between objects like an auto a which is modeled as constant and integral numbers like 42.
This class provides an acceptability interpretation of arguments by assigning them real values.
Possible sorting types for the numerical values.
An observation is some data point which can be classified.
Provides a bridge to the Octave (http://www.gnu.org/software/octave/) optimization solver "sqp" which implements a successive quadratic programming solver for general non-linear optimization problems.
This class implements an example for the OctaveSqpSolver.
OfflineAlgorithm<S extends State,A extends Action>
A general interface for algorithms to determine optimal policies directly from an MDP
Provides some utility functions for solving quadratic problems with ojAlgo.
Provides some utility functions for solving Pcl specific reasoning problems with ojAlgo.
Provides an interface to the open-wbo MaxSAT solver, see https://github.com/sat-group/open-wbo.
This enumeration lists the possible Operations used by dynamic preference aggregation updates
P is optimistic wrt.
This class represents an element of an optimization statement, meaning a term-literal tuple that is associated with a weight and optionally a priority (level).
This class models a general optimization problem.
This class is the common ancestor for root finders that work with optimizers.
This class represents an optimization statement.
Implementation of the iterative algorithm for learning argumentation frameworks from labelings utilizing the parallelization possibilities
An example for using optimization statements, taken from the clingo guide, chapter 3.1.13 https://github.com/potassco/guide.
 
This class represents an order among some objects.
 
This class models single fields used for the PluginOutput Each field contains its description and its value, e.g.: Query: a + b || !a + !b where "Query:" is the description and "a + b || !a + !b" is the value.
This class models an abstract reasoner for structured argumentation frameworks.
This class models an overcautious argumentation agent, i.e.
This inconsistency measure measures the distance between a given partial probability assignment to the set of rational/justifiable probabilistic extensions of a given Dung theory.
Example code for the PAInconsistencyMeasure.
 
This class implements a simple pair of elements.
 
 
This class represents a selective revision using the base revision approach from [1] for the inner revision and the sceptical argumentative transformation function from [2].
 
A set of parameters that can be given to a trainer to specifiy the training task.
Performs a parameter training on a given trainer, i.e.
This operator implements a revision of some probabilistic assessment of arguments upon the observation of an argumentation theory.
 
This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
 
Parser<T extends BeliefBase,S extends Formula>
This class models an abstract parser for belief bases and formulas.
This class models a general exception for parsing.
A partial probability assignment for abstract argumentation theories.
This interface contains common methods for probabilistic argumentation semantics.
This operator implements an update of some probabilistic assessment of arguments upon the observation of an argumentation theory.
This class models a belief set on probabilistic conditional logic, i.e.
This class is capable of restoring consistency of a possible inconsistent probabilistic conditional belief set.
This class is capable of checking whether a given conditional knowledge base is consistent by searching for the root of some equivalent multi-dimensional function.
This class implements a parser for probabilistic conditional logic.
The interface for PEAFInducers, these create a subset of the graph that is generated from the given PEAF
This class implements an abstract argumentation theory in the sense of Probabilistic Evidential Argumentation Frameworks (PrEAF).
This class implements an abstract argumentation theory in the sense of Probabilistic Extended Evidential Argumentation Frameworks (PrEEAF).
The exception occurs when the element requested is not found.
Helper class for displaying associated exceptions' occurrence
The exception occurs when the argument requested is not found.
This class is capable of restoring consistency of a possible inconsistent probabilistic conditional belief set.
A perceivable object is some event occuring in an environment and perceivable by an agent.
This class packs a structured argumentation framework into a perceivable object.
A class to represent a Petri net
An abstract class for the two types of nodes in a Petri net, places and transitions
A class to map a BPMN model to a Petri net
This class is for displaying instances of the PetriNet class graphically
 
 
*description missing*
Provides a simple ping service that always returns the request sent to it.
A class to describe places in a Petri net
This class represents a knowledge base of propositional formulae.
Some general examples for using basic propositional logic classes like PlParser and SimplePlReasoner.
An Exception for the propositional language, it is thrown if a developer tries to create illegal propositional statements like a predicate with an arity greater than zero.
This class represents the common ancestor for propositional formulae.
Implements RuleFormulaGenerator for propositional logic.
This abstract class models a MUS enumerator for propositional logic, i.e.
A class for managing and displaying several plots in a single frame
This class is responsible for the behavior of a plotter with multiple frames.
This class implements a parser for propositional logic.
Manages and creates different parsers for propositional logic.
An enumeration of all available knowledge base formats.
JUnit Test class for PlParser.
Adapted from "PlParser" for the use of 3-valued logic (WeakNegation and Indecision-Operator):
This class provides the JSPF-Plugin for the propositional logic library Currently plugin is loadable but not executed
A specialized predicate for propositional logic that only allows an identifier but has no arguments and therefore has an arity of zero.
This class captures the signature of a specific propositional language.
This class provides the output for each plugin to be used in the CLI.
Creates an aggregator with plurality scoring
A window inconsistency measurement process for propositional logic (this class needs to be there as no generics are allowed when instantiating a DefaultStreamBasedInconsistencyMeasure.
This class implements a writer for propositional formulas and belief bases.
This class implements the inconsistency measure I_{P_m} proposed in [Jabbour, Raddaoui.
This class implements the inconsistency measure $I_\pm$ from [Ulbricht, Thimm, Brewka.
Example code illustrating the Pm inconsistency measure.
The p-norm.
This class is meant to provide a structure to change preference orders and compare the results between changes
This generator generates abstract argumentation frameworks following the schema described in "Strong Admissibility Revisited" (COMMA2014) by Martin Caminda, following and idea by Mikolay Podlaszewski.
Policy<S extends State,A extends Action>
A policy (map from states to actions) for Markov Decision Process
PolicyEvaluation<S extends State,A extends Action>
 
PolicyIteration<S extends State,A extends Action>
The policy iteration algorithm for determining optimal policies
A decorator which provides a pool of pre computed SatSolverState.
 
 
Token literal values and constants.
 
This class performs the Gamma Operator for Possibilistic ADFs introduced in [Heyninck 2021]
This class models the possibility modality.
Models a possibility distribution (PD) as defined in Christoph Beierle / Gabriele Kern-Isberner: Methoden Wissensbasierter Systeme
This class represents a possible world of propositional logic, i.e.
This class refines interpretation distances to distance on possible worlds.
Iterates effectively over all interpretation sets worlds of a given signature.
*description missing*
Models a general (rationality) postulate, i.e.
Classes implementing this interface can be evaluated wrt.
Summarises the results of a postulate evaluation.
PostulateEvaluator<T extends Formula,U extends BeliefSet<T,?>>
Evaluates some approach (reasoner, measure, etc.) wrt.
This class represents a term raised to some power.
 
A general predicate which contains an identifier that describes its meaning, an argument count referred as arity and a list of sorts defining the types for the arguments of the predicate.
This interface is meant to be used for the aggregation of some generic preference orders
The implementation orients on the diploma thesis of Mirja Boehmer in this class a variant of the approach "A Preference-Based Framework for Updating Logic Programs" by James P.
This class extends the BinaryRelation-class with a check for totality and transitivity
 
The CLI-Plugin for the Preferences-Package
Computes the preferred extension of the given PEAF
*description missing*
This reasoner for ABA theories performs inference on the preferred extensions.
Deprecated, for removal: This API element is subject to removal in a future version.
a set of arguments S is preferred iff it is maximal wrt.
a set of arguments S is preferred iff it is maximal wrt set inclusion admissible.
This class implements a revision operator for Abstract Dialectical Frameworks (ADFs)
 
A three-valued interpretation for propositional logic from Priest's three valued logic (3VL) [Priest, G.: Logic of paradox.
The three truth values.
This class models a three-valued interpretation for propositional logic from Priest's three valued logic (3VL) [Priest, G.: Logic of paradox.
The three truth values.
This class iterates effectively over all interpretation sets worlds of a given signature.
computes the inconsistency measure of the
prime implicant enumerator
 
Models a principle for argumentation semantics i.e.
Example code for principles for argumentation semantics
This class models the P inconsistency measure from e.g.
This distance function uses an aggregator on a probabilistically normalized distance for probabilities of each value.
This class implements the probabilistic argumentation framework approach of [Li, Oren, Norman.
This class represents a probabilistic conditional of the form (B|A)[p] with formulas A,B and a probability p.
This class implements a probabilistic interpretation for Dung argumentation frameworks, cf.
probablisitic justification analysis
An agent in a game of argumentation lotteries.
Generates lottery agents.
This class implement the p-norm distance function where distances are normalized corresponding to their distance to 0.5.
Implements a graded semantics reasoner based on the ideas from [Thimm, Cerutti, Rienstra.
Example code for using the probabilistic ranking reasoner based on the ideas from [Thimm, Cerutti, Rienstra.
Represents the probabilistic sum in fuzzy logic, i.e., S(x,y)=x+y-xy
This class represents a probability, i.e.
 
This class represents a probability distribution on some logical language
This class represents a probability distribution over some set of objects
This exception is thrown when a problem cannot be solved due to its inconsistency.
This exception is thrown when a problem cannot be solved due to its inconsistency.
This reasoner makes use of an external executable for solving reasoning problems in abstract argumentation.
This enum contains all supported problems for probo-based reasoner.
The actual computational sub-problem.
This reasoner makes use of an external executable for solving reasoning problems in abstract argumentation.
*description missing*
 
A class to represent processes in a BPMN Model
 
Parse a process in a BPMN model
This class models a product of two terms.
This aggregation function models the product function.
Represents the product-norm in fuzzy logic, i.e., T(x,y)=xy
This class models an ASP-Core-2 program, meaning a set of rules and optionally a query.
This class implements the argument ranking approach of [Delobelle.
The three propagation semantics: PROPAGATION1 ("Propa_epsilon") PROPAGATION2 ("Propa_{1+epsilon}") PROPAGATION3 ("Propa_{1->epsilon}")
This class represents a simple proposition in propositional logic.
Contains the propositional representation of the arguments and links of some ADF.
A protocol gives instructions in which order agents have to be asked for actions in a multi-agent system.
Generates protocols for simulation.
A protocol listener listens on a protocol and is notified whenever an action is executed.
A ProtocolTerminatedException is thrown when a protocol is asked to perform a step but has already terminated.
Invokes Prover9 ( https://www.cs.unm.edu/~mccune/mace4/), an automated theorem prover for first-order logic, and returns its results.
JUnitTest to test Prover9
Prints single first-order logic formulas and full knowledge bases to Prover9 format (https://www.cs.unm.edu/~mccune/mace4/manual/2009-11A/).
Some general examples for quantified boolean formulas and for parsers and writers.
This class implements a parser for quantified boolean formulas.
Examples for using QBF solvers.
Abstract QBF sat solver to be implemented by concrete solvers.
Test class for basic qbf functionalities.
This class represents a possible world of quantified boolean logic, i.e.
This class implements a parser for the QCIR (Quantified CIRcuit) format.
Test class for parsing QCIR files.
This class implements a parser for the QDIMACS input format.
Possible answers that solvers can find for a given QDIMACS problem.
Test class for parsing QDIMACS files.
Converts belief bases to QDIMACS format and prints them.
This class implements a simple quadruple of elements.
This class models a signature as four sets of formulas.
Example on how to use the qualified and semi-qualified semantics reasoners.
Reasoner for qualified sigma-semantics.
The general interface for objects that are able to query a belief base with some formula and return either TRUE or FALSE as answer.
Interface for a QuantifiedFormula with a set of quantified variables implementing an all- or exist-quantor for example.
This class provides common functionalities for quantified formulas, i.e.
The general interface for objects that are able to query a belief base with some formula and return a degree (double value) of its acceptability.
 
Action queries are represented as propositional formulas with three possible types of propositions: "holds", "always" and "necessarily" propositions.
A wrapper for the Qute (https://www.ac.tuwien.ac.at/research/qute/) solver.
The "abstraction" postulate for ranking semantics as proposed in [Amgoud, Ben-Naim.
The "addition of attack branch" postulate for ranking semantics as formalized in [Bonzon, Delobelle, Konieczny, Maudet.
The "addition of defense branch" postulate for ranking semantics as formalized in [Bonzon, Delobelle, Konieczny, Maudet.
The "attack vs full defense" postulate for ranking semantics as proposed in [Bonzon, Delobelle, Konieczny, Maudet.
The "cardinality precedence" postulate for ranking semantics as proposed in [Amgoud, Ben-Naim.
The "counter-transitivity" postulate for ranking semantics as proposed in [Amgoud, Ben-Naim.
The "defense precedence" postulate for ranking semantics as proposed in [Amgoud, Ben-Naim.
The "distributed-defense precedence" postulate for ranking semantics as proposed in [Amgoud, Ben-Naim.
The "increase of attack branch" postulate for ranking semantics as formalized in [Bonzon, Delobelle, Konieczny, Maudet.
The "increase of defense branch" postulate for ranking semantics as formalized in [Bonzon, Delobelle, Konieczny, Maudet.
The "independence" postulate for ranking semantics as proposed in [Amgoud, Ben-Naim.
Generates random ASPIC argumentation theories.
This class implements an approximate reasoner for ASPIC+ that randomly samples arguments.
 
This class implements an incision function that just randomly selects a minimal incision.
This class implements a simple kernel base contraction for propositional logic with an incision function that randomly selects its incisions.
A baseline agent for argumentation games who always returns some random move.
Generates baseline lottery agents.
 
A sampler for uniform random k-SAT instances.
Iterates over all subsets of a given sets in a random order.
A ranking function (or ordinal conditional function, OCF) that maps possible worlds of a propositional language to integers.
This class is meant to provide ranking functions to given preference orders and vice versa.
A ranking function (or ordinal conditional function, OCF) that maps possible worlds of a propositional language to integers.
An abstract postulate for ranking-based semantics in abstract argumentation; the ancestor of all concrete postulates.
Example code for evaluating ranking semantics in regard to postulates.
Test class for checking counterexamples for some postulates.
Example code for the following ranking semantics:
- Categorizer [Besnard, Hunter.
Example code for even more ranking semantics:
- Counting Semantics [Pu, Zhang, G.Luo, J.Luo.
Test class for basic ranking functionalities.
This class contains common utility methods for ranking reasoners.
The "non-attacked equivalence" postulate for ranking semantics as proposed in [Bonzon, Delobelle, Konieczny, Maudet.
The "quality precedence" postulate for ranking semantics as proposed in [Amgoud, Ben-Naim.
The "self-contradiction" postulate for ranking semantics as proposed in [Matt, Toni.
The "strict addition of defense branch" postulate for ranking semantics as formalized in [Bonzon, Delobelle, Konieczny, Maudet.
The "strict counter-transitivity" postulate for ranking semantics as proposed by [Amgoud, Ben-Naim.
P is rational wrt.
The "total" postulate for ranking semantics as proposed in [Bonzon, Delobelle, Konieczny, Maudet.
The "void precedence" postulate for ranking semantics as proposed by [Amgoud, Ben-Naim.
This class models a belief set on relational conditional logic, i.e.
Example code illustrating the use of working with relational conditionals and using c reasoning.
This class implements a parser for relational conditional logic.
Example code illustrating Reiter's default logic.
 
This class implements a parser for default logic.
A class to describe the graph of reachability between possible markings of a Petri net
 
This class is for displaying instances of the ReachabilityGraph class graphically
A norm for real vector spaces.
Reasoner<O,B extends BeliefBase,F extends Formula>
The general interface for objects that are able to query a belief base with some formula.
Compares reasoning with different reasoners.
This notion of attack models the rebut relation.
This attack notion models the rebuttal relation; A is defeated by B iff claim(B) == \neg claim(A).
This class realizes a recognition function as explained in [Rienstra, Thimm, in preparation].
Reduct-Admissibility Principle A semantics satisfies reduct admissibility iff for every AF F and every extension E we have: For all arguments a in E: if an argument b attacks a, then b is in no extension of the E-reduct of F see: Dauphin, Jeremie, Tjitze Rienstra, and Leendert Van Der Torre.
Instances of this class represent reference worlds, i.e.
Prevents smaller interpretations from being computed, but also allows different interpretations of at least the same size.
 
Reinstatement Principle A semantics satisfies reinstatement if for all extensions E it holds that: for all arguments a, if E defends a, then a is in E i.e E is a complete extension see: Baroni, P., and Giacomin, M.
This enumeration lists the possible relations between two elements in preference orders
Instances of this class represent relational conditionals.
This is the abstract base class for relational formulas, i.e.
This class represents a relational probabilistic conditional, i.e.
A relational ranking function (or relational ordinal conditional function, ROCF) that maps Herbrand interpretations to integers.
A SatEncoding which is relative to a given interpretation.
This class represents the set of remainder sets constructed from a belief base.
Example code illustrating the use of repairing approaches.
*description missing*
*description missing*
*description missing*
 
 
 
*description missing*
The data-model used to compare two different revision approaches.
This class couples the RevisionCompare View and Model, it needs to know the implementation used to load external belief base files, see FileHandler interface.
This interface is used by the RevisionComparePresenter to handle the file loading.
The default view for a revision compare.
Uses the RevisionCompareView in a JFrame to compare the different revision methods in ASP.
This class models a rigid protocol, i.e.
Implementation of the algorithm for learning (grounded) labelings from: Riveret, Régis, and Guido Governatori.
This class models a role assertion in description logic, i.e.
This class represents a the nth root function
Classes which extend this class represent algorithms for finding zero points (roots) of functions.
Instances of this class serve as the root of a parsing process for a BPMN XML file.
This class models a round robin protocol for multi-agent systems.
This class models a belief set on relational probabilistic conditional logic, i.e.
 
 
 
General ME-reasoner for RPCL.
Example code illustrating relational probabilistic conditional logic and reasoning with it.
Example code illustrating relational probabilistic conditional logic and reasoning with it.
Example code illustrating relational probabilistic conditional logic and reasoning with it.
This class implements a parser for relational probabilistic conditional logic.
relational probabilistic conditional logic plugin for the tweety cli skeleton
Objects of this class represent probability distributions on the interpretations of an underlying first-order signature for a relational probabilistic conditional knowledge base.
 
Token literal values and constants.
Token Manager.
This interface describes semantics for relational probabilistic logic.
Rule<C extends Formula,P extends Formula>
This interface models a general rule, i.e.
A simple adapter class that wraps the straightforward methods of the Rule interface, such that the developer can spare the work to implement the setter methods.
This is a reasoner using c-representation and rules to solve these c-representations.
A rule that is applicable by the RuleBasedCReasoner to reason a c-representation given a conditional belief base.
 
This class transforms a defeasible ASPIC inference rule into a corresponding formula, i.e.
RuleSet<T extends Rule<?,?>>
This class represents a set of rules and provides several auxiliary methods for accessing such a set.
This class implements methods to test the class "PossibilityDistribution"
This class represents a single action query in the action query language S, which is based on the query language "P" discussed in the paper: Action Languages.
This class provides methods capable of checking if a given transition system satisfies a set of action queries in the action query language S.
This class models a set of action queries in the language "S" which is based on the query language "P" discussed in the paper: [Gelfond, Michael and Lifschitz, Vladimir: Action Languages.
a set of arguments S is safe wrt.
Example code for using social abstract argumentation.
Example code for using social abstract argumentation.
This class implements the social abstract argumentation approach as proposed by [Bonzon, Delobelle, Konieczny, Maudet.
This class represents an agent in a structured argumentation system.
Uses the Sat4j library for SAT solving (note that currently only the light version is used).
A common base class for inconsistency measure implementations based on SAT encodings.
Uses a SAT solver to determine complete extensions.
 
Computes the LinkType via two Sat-calls.
 
Uses the default SAT reasoner to perform reasoning in propositional logic
Abstract class for specifying SAT solvers.
A minimalistic, low-level and stateful SAT solver interface.
Example code illustrating the use of external SAT solvers such as Lingeling and CaDicaL, and related utilities.
A high level representation of a sat solver state.
Uses a SAT solver to determine stable extensions.
Reasoner for CF2 extensions using scc-recursiveness.
SCC Decomposability Principle also: SCC-Recursiveness A semantics satisfies SCC decomposability iff for all AFs we have: The extensions of F are the same as computing the extensions of each SCC individually and combining the result see: Pietro Baroni et al.
This class represents the sceptical transformation function for literals as introduced in [1].
 
Reasoner for SCF2 extensions using scc-recursiveness.
reasoner for SCOOC-naive semantics.
Strong Complete Completeness Outside Odd Cycles Principle (SCOOC) A semantics satisfied SCOOC if for every extension E it holds that: for every argument a, if neither a nor its attackers are in an odd cycle and E does not attack a, then a is in E.
This class extends the interface for preference aggregation with scoring Scorings are implemented separately.
The class ScoringPreferenceAggregatorTest contains tests for the class ScoringPreferenceAggregator.
This class implements the screened maxi-choice consolidation operator from [1].
This class represents the set of Screened Consistent Remainder Sets as defined in [1].
This class implements the inconsistency measure $I_sd$ from [Ulbricht, Thimm, Brewka.
Implements the SEE approach ("selective extension enumeration") to determine the set of acceptable arguments of an AF wrt.
Implements the SEEM approach ("selective extension enumeration with MaxSAT") to determine the set of credulously acceptable arguments of an AF wrt.
This class expands the CommandParameter with a selection-array containing strings the parameter supports
This interface models a general selection function for remainder sets
This class implements a selective revision operator following [Ferme:1999].
a set of arguments S is self-supporting iff all arguments in S are e-supported by S.
Provides access to the computational building blocks of SAT based ADF semantics.
This enum lists all semantics.
 
P is semi-founded wrt.
P is semi-optimistic wrt.
Semi-Qualified Admissibility Principle A semantics s satisfies semi-qualified admissibility iff for every AF F and every s-extension E we have: For all arguments a in E: if an argument b attacks a and b is in any s-extension, then E attacks b see: Dauphin, Jeremie, Tjitze Rienstra, and Leendert Van Der Torre.
Reasoner for semi-qualified sigma-semantics.
A class to represent edges of the sequence flow in a BPMN Model
Parse an edge of the sequence flow in a BPMN model
 
Abstract class for computing extensions via a serialised transition system to implement this class, you need to define a selection and a termination function Selection function a(UA, UC, C): selects and returns a subset of the initial sets Termination function b((AF, S)): If the given state satisfies a specific condition, its extension may be accepted by the associated serialised semantics
This class summarises examples displaying the usage of SerialisableExtensionReasoner for different types of serialisable semantics.
Implements the serialisable ranking semantics from [Blümel, Thimm.
 
This class summarizes static methods used to plot serialisability analyses, consisting of plotting the underlying argumentation framework and the serialisation graphs regarding the specified semantics.
This class represents a summary of examples to show the use of SerialisationAnalysisPlotter.
This class represents an comparator, which defines if 2 frameworks are equivalent, by comparing their serialisability.
This class represents an comparator, which defines if 2 frameworks are equivalent, by comparing their serialisation graphs.
This class represents an comparator, which defines if 2 graphs are equivalent, by comparing if they're isomorphic.
This class represents an comparator, which defines if 2 graphs are equivalent, by comparing their set of nodes.
This class represents an comparator, which defines if 2 frameworks are equivalent, by comparing their serialisation sequences.
This class represents an comparator, which defines if 2 sets of sequences are equivalent.
This class represents an comparator, which defines if 2 frameworks are equivalent, by comparing their sequences of transition states.
This class represents an comparator, which defines if 2 sets of TransitionStateSequences are equivalent.
This class represents a graph visualising the different Extension during the generation process of serialisable extensions.
This class represents a generator for exemplary frameworks with serialisable extensions.
This class summarises examples displaying the usage of SerialisationGraphGenerator for a chosen type of serialisable semantics.
This class represents a specialization of GraphPlotters used to visualize the process of generating extensions by serialising sets of arguments, as realised in SerialisableExtensionReasoner.
This class summarises examples displaying the usage of SerialisationGraphPlotter for a chosen type of serialisable semantics.
This class represents a sequence of sets of arguments.
Tests to verify the code in the class SerialisationSequence.
Serialised version of the admissible semantics
Serialised version of the complete semantics
Serialised version of the grounded semantics
Serialised version of the preferred semantics
Serialised version of the stable semantics
This class represents a reasoner to compute the extensions of the strongly admissible Semantics by serialising unattacked initial sets.
Serialised reasoner for the unchallenged semantics The unchallenged semantics amounts to exhaustively adding unattacked and unchallenged initial sets
This class implements a SetAF in the sense of Nielson/Parson:

See

Nielsen, Soren Holbech and Parsons, Simon.
This class captures the signature of a SetAf theory, i.e.
Examples of SetAf Theorys and their semantics
Examples of SetAf Theorys and their semantics
This class models an attack between a set of arguments and an argument.
This class models an attack between two arguments.
 
This class models a support between a set of arguments and an argument.
This class provides some methods for set operations.
SetTrie<T extends Comparable<T>>
This class provides a general implementation of a set-trie as defined in [Iztok Savnik: Index Data Structure for Fast Subset and Superset Queries.
This class implements the Shapley culpability measure.
 
A signatures lists the atomic language structures for some language.
Classes implementing this interface represent signed culpability measures, i.e.
This implementation of an accumulator simply sums up the categorizations of the argument trees.
This reasoner for Dung theories performs inference on the admissible extensions.
This reasoner for SetAf theories performs inference on the admissible extensions.
Naive implementation of the iterative algorithm for learning argumentation frameworks from labelings
 
A simple comparator for Aspic Arguments, that compares their top rules according to a given list of rules
 
Implementation of the acceptance conditions used for learning argumentation frameworks from labelings Notation: for each acceptance condition we also store the argument a it is associated with In the condition itself we then use !b and b to represent !r_(ba) and r_(ba) respectively e.g.
 
 
An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).
An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).
 
calculates claim based inherited extensions
calculates claim based naive extensions
calculates claim based preferred reasoner
a simple claimbased semi stable reasoner
a claim based stable reaonser
calculates claim based staged extensions
This reasoner for Dung theories performs inference on the complete extensions.
This reasoner for SetAf theories performs inference on the complete extensions.
This reasoner for Dung theories performs inference on the conflict-free extensions.
This reasoner for SetAf theories performs inference on the conflict-free extensions.
This class models a brute force c-reasoner for conditional logic.
This class implements a brute force approach to deductive argumentation.
Implements a naive reasoner for default logic based on exhaustive application of defaults in process trees.
This class provides a simple reference implementation of the DPLL (Davis–Putnam–Logemann–Loveland) algorithm for satisfiability testing, see e.g https://en.wikipedia.org/wiki/DPLL_algorithm.
 
simple reasoner for eager semantics
simple reasoner for eager semantics
Uses a naive brute force search procedure for theorem proving.
Encapsulates common methods of mathematical functions with a single parameter.
This class implements a simple genetic optimization algorithm for solving optimization problems with box or equality constraints on float variables.
 
This class implements an example for the Genetic Optimization Solver.
 
SimpleGraph<T extends Node>
An extended version of the DefaultGraph which supports removing of nodes as well as some utility functions for d-separation
This reasoner for Dung theories performs inference on the grounded extension.
This reasoner for SetAf theories performs inference on the grounded extension.
This reasoner for Dung theories performs inference on the ideal extension.
This reasoner for setAf theories performs inference on the ideal extension.
Basic Implementation of a reasoner for initial sets A set of arguments S is considered initial iff it is non-empty and minimal among the non-empty admissible sets see: Yuming Xu and Claudette Cayrol.
A formula of a logical language
comptes all minimal models given a set of models
 
This class implements inference for modal logic using a brute-force approach.
enumerates all models naivly
Reasoner for naive extensions.
Reasoner for naive extensions.
A simple node of a graph with a name.
 
This class implements a naive algorithm for computing probabilities of extensions in probabilistic argumentation frameworks from [Li, Oren, Norman.
Implements an exhaustive search approach to compute all interpolants of a knowledge base wrt.
Illustrates the use of the SimplePlInterpolantEnumerator
 
 
Example code for simple logic argumentation.
 
Naive classical inference (checks all interpretations for satisfiability).
Basic data structure for handling simple rule
This reasoner for Dung theories performs inference on the preferred extensions.
This reasoner for setaf theories performs inference on the preferred extensions.
computes the prime implicants given a set of minimal models
The simple product semantics from [Leite, Martins; IJCAI 2011, Def.
A real-valued function.
This class models a relational brute force c-reasoner for relational conditional logic.
This reasoner for Dung theories performs inference on the resolution-based family of semantics.
The data-model used to compare two different revision approaches.
This class couples the SimpleRevisionCompare View and Model, it needs to know the implementation used to load external belief base files, see FileHandler interface.
This interface is used by the SimpleRevisionComparePresenter to handle the file loading.
The default view for a revision compare.
This class implements a belief base sampler for structured argumentation frameworks.
This MLN reasoner employs simple random sampling from the set of interpretations to compute the probability of a formula.
This reasoner for Dung theories performs inference on the complete extensions.
Universal scc-recursive reasoner initialize with any reasoner for a scc-recursive semantics
This reasoner calculates claim based semi stable extensions
This reasoner for setaf theories performs inference on the semi-stable extensions.
This reasoner for Dung theories performs inference on the stable extensions.
This reasoner for setaf theories performs inference on the stable extensions.
This reasoner for Dung theories performs inference on the stage extensions.
This reasoner for setaf theories performs inference on the stage extensions.
This class implements the simulated annealing algorithm for combinatrics problems It is natively implemented
implements the Simulated Annealing algorithm for optimization problems
This class implements an example for Simulated Annealing on optimization problems.
Objects of this class store additional simulation parameters that should be shared among the generating components of a simulation.
Instances of this class summarize information on a performed simulation.
The single peak implementation of the weight vector, where only the highest rated value in each preference order scores (1,0,0,0,0,0)
This class models a signature as a set of formulas.
 
This class is capable of restoring consistency of a possible inconsistent probabilistic conditional belief set.
A function that smoothes two values with a smooting factor, i.e.
This class implements a social abstract argumentation framework from [Joao Leite, Joao Martins.
Implements a mapping from arguments to social value.
Reasoner for solid admissibility a set of arguments E solid-defends an argument a, iff for all attackers b of a it holds that all arguments c which attack b are in E see: Liu, X., and Chen, W.
This abstract class models an abstract solver for constraint satisfaction or optimization problems.
This class models a generic exception for ASP solvers.
 
A sort of first-order logic.
Invokes SPASS (http://www.mpi-inf.mpg.de/departments/automation-of-logic/software/spass-workbench/), an automated theorem prover for first-order logic, modal logic and description logics.
Invokes SPASS (http://www.mpi-inf.mpg.de/departments/automation-of-logic/software/spass-workbench/), an automated theorem prover for first-order logic, modal logic and description logics.
JUnitTest to test SPASS (test cases from TPTPTest)
JUnit Test class for SPASS Prover for modal formulas.
This class prints single first-order logic formulas and knowledge bases to the SPASS format.
This class prints single first-order modal logic formulas and knowledge bases to the SPASS format.
This class captures the common functionalities of the special formulas tautology and contradiction.
This class captures the common functionalities of the special formulas tautology and contradiction.
Kernel SK = (A, R') for strong equivalence wrt.
This reasoner for ABA theories performs inference on the stable extensions.
Deprecated, for removal: This API element is subject to removal in a future version.
a set of arguments S is stable iff it is conflict-free, self-supporting and for any argument a e-supported by bbase, where a is not in S, S e-support attacks either a or every set of arguments minimally e-supporting a.
a set of arguments S is stable iff the set of arguments deactivated by S equals A\S, where A is the set of all arguments in the argumentation framework.
Verifies if a given interpretation is stable by comparing it with the ground interpretation of its omega reduct.
Reasoner for Stage2 semantics using scc-recursiveness definition see: Dvorak, Gaggl: Incorporating Stage Semantics in the SCC-recursive Schema for Argumentation Semantics 2012
This class represents an comparator, which defines if 2 argumentation frameworks are equivalent, by comparing if they have the same extensions wrt a semantics specified by a reasoner.
Writes FOL formulas and knowledge bases in the standard TweetyProject format, see parser.FolParser.
Shows how to use the StandardFolWriter.
A class to represent the starting events of a BPMN Model
Parse a start event of a BPMN model
Represents a state in an action transition system, which is a representation of an interpretation of all fluent names in an action description.
A state in a Markov Decision Process
This class models a mathematical statement, i.e.
 
This class represents a static rule in C, which has the following form: "caused H if G" where H is a propositional formula over the set of fluents and G is a propositional formula over the set of fluents and the set of actions
local search
Stochastic Local Search On Constraint Problem
This class implements an example for Simulated Annealing on optimization problems.
This class implements the argument ranking approach of [Matt, Toni.
This class implements stratified labelings as in [Thimm, Kern-Isberner, 2013].
Example code for using stratified labelings by Thimm/Kern-Isberner.
This class implements a stratified labeling reasoner.
General interface for inconsistency measures working on streams.
Illustrates stream-based inconsistency measurement.
Illustrates stream-based inconsistency measurement.
Indefeasible implementation of InferenceRule<T>
This class models the strict negation of an atom (as opposed to a default negation: DefaultNegation).
This class models a strict rule in defeasible logic programming.
This class models a string list command parameter for Work-in-Progress, do not use!
This class represents terms which are objects identified by a string.
Principle of Strong Admissibility A semantics satisfies strong admissibility iff for every extensions E in every AF it holds that: all arguments in E are strongly defended by E, i.e.
*description missing*
Kernel SK = (A, R') for strong equivalence wrt.
This notion of attack models the strong attack relation.
This notion of attack models the strong confident attack relation.
Models strong equivalence wrt.
Example usage of the StrongEquivalenceChecker class
Reasoner for strong admissibility A set of arguments E is strongly admissible iff all every argument A in E is defended by some argument B in E \ {A}, which itself is strongly defended by E \ {A}, i.e.
Implements the strongly undisputed semantics, as proposed in [Thimm.
This notion of attack models the strong undercut relation.
This class represents a structured argumentation framework, i.e.
This class represents a structured argumentation system, i.e.
Represents a probability function on the subgraphs of some Dung theory.
Example code for showing how to work with subgraph probability distributions and updates.
Iterates over all subsets of a given set.
Class SubsetIteratorExample
This class models a sum of two terms.
This aggregation function models the sum function.
This interface captures common methods of different interpretations of the support relation in bipolar abstract argumentation theories.
Realizes a support vector machine classifier utilizing LIBSVM.
Illustrates the use of support vector machine learning.
tests SVM
A synchronized wrapper of SatSolverState.
This class models a synchronous protocol for multi-agent systems.
Generates all syntactic variations of knowledge bases
Illustrates the use of the belief base enumerators.
Illustrates the use of the belief base enumerators.
This sampler implements a random generation algorithm for generating formulas, based on the syntax tree of propositional formulas.
This belief state consists of a simple recursive opponent model.
This class encapsulates configuration options for generating T1 belief states.
This belief state consists of a probability distribution over other opponent models.
This class encapsulates configuration options for generating T2 belief states.
This belief state consists of a probability distribution over other opponent models with virtual arguments.
This class encapsulates configuration options for generating T3 belief states.
implements a simple Tabu Search without long term memory for combinatorics problems
implements a simple Tabu Search without long term memory for optimization problems
This class implements an example for Tabu search.
A class to represent tasks in a BPMN Model
Parse a task of a BPMN model
 
Possible types of tasks in a BPMN model
A tautological formula.
A tautological formula.
 
Represents a T-norm in fuzzy logic, i.e., a generalization of a logical conjunction on values in [0,1].
A term of a logical language, that can be given as argument for logical constructs like atoms or functors.
This class models a mathematical term.
Abstract base class implementing the substitute(), getSort(), getTerms(), and containsTermsOfType() methods in a way it is useful for terms.
Testing argument syntax.
 
Testing the command line stuff for DeLP.
Testing dialectical trees.
Testing DeLP formula parsing.
Parsing DeLPs.
 
Testing some example KBs with various queries.
Tests for rules: facts, strict and defeasible rules.
testing the function to model a quadratic function to quadratic form
Enumerates all belief bases from a text file; the file contains one belief base per line.
Filename filter for TGF files.
Parses abstract argumentation frameworks given in the trivial graph format which is given by the following BNF (start symbol is S):

S ::== ARGUMENTS "#" "\n" ATTACKS
ARGUMENTS ::== "" | ARGUMENT "\n" ARGUMENTS
ATTACKS ::== "" | ATTACK "\n" ATTACKS
ATTACK ::== ARGUMENT ARGUMENT
where "ARGUMENT" represents any string (without blanks) as a terminal symbol.
Writes an abstract argumentation framework into a file of the TGF format.
Improved version of the MaxSAT algorithm from: Niskanen, Andreas, Johannes Wallner, and Matti Järvisalo.
Inspired by BitSet but with three values.
This class models a three-valued interpretation for propositional logic Formulas are interpreted using completions Every atom is assigned one of the three truth values: TRUE, FALSE, UNDECIDED.
The three truth values.
Represents a T-norm in fuzzy logic, i.e., a generalization of a logical conjunction on values in [0,1].
 
Describes the input token stream.
Describes the input token stream.
Describes the input token stream.
Describes the input token stream.
 
Token Manager Error.
Token Manager Error.
Token Manager Error.
Token Manager Error.
This class models the top concept (universal concept) in description logics.
This class implements a parser for the TPTP syntax that parses single fol formulas and knowledge bases (TPTP problem files or axiom files).
Examples for using TPTPParser.
JUnitTest to test TPTP printer and EProver implementation
Prints single first-order logic formulas and full knowledge bases to TPTP format.
Trainer<S extends Observation,T extends Category>
 
A single parameter for a training method.
A set of observations together with their category.
This interface represents a transformation function for selective revision [Ferme:1999].
Transforms an acceptance condition into an arbitrary structure.
Represents a transition in an action transition system, which is a representation of the execution of an action which causes a state change from a source state to a target state.
A class to describe transitions in a Petri net
A state of the transition system for serialised semantics It consists of an argumentation framework and a set of arguments
This class represents a sequence of TransitionStates.
This class represents an action transition system for a fixed action signature with a set of states and a set of transitions between states.
Tests the FOLPropTranslator
 
Allows translation between different logic languages, sub classes have to implement the translation between complex formulas but this base class provides methods to translate, predicates, Atoms, Associative formulas and Rules.
implements the traveling salesman problem.
This class implements an example for the ant colony algorithm using isula for combinatrics problems
Class implementing an example for a TSP on a cartesian fully connected graph
Class implementing an example for a TSP on a cartesian fully connected graph
Class implementing an example for a TSP on a cartesian fully connected graph
Class implementing an example for a TSP on a cartesian fully connected graph
Class implementing an example for a TSP on a cartesian fully connected graph
Class implementing an example for a TSP on a cartesian fully connected graph
This class implements a simple triple of elements.
This class models a signature as three sets of formulas.
This class models a truthful argumentation agent, i.e.
 
This class implements the "tuples*" argument ranking approach as proposed by [Cayrol, Lagasquie-Schiex.
This class implements a simple command line interface for accessing the functionalities provided by the TweetyProject libraries.
This interface contains some configuration options for Tweety.
The possible log levels.
This class provides the base for each plugin's functionality
Uses the Grizzly HTTP server to instantiate the TweetyProject server that provides API access to TweetyProject services.
 
 
This interface defines method which are given by every TypedStructure like a Predicate or an Functor.
The abstract parent for predicates and functors implementing the TypedStructure interface.
This class is capable of restoring consistency of a possible inconsistent probabilistic conditional belief set.
Kernel SK = (A, R') for strong equivalence wrt.
This attack notion models the undercut relation; A is defeated by B iff there is C subset of support(A) with claim(B) == \neg C.
This notion of attack models the undercut relation.
Instances of this class represent undirected edges.
Implements the undisputed semantics, as proposed in [Thimm.
 
 
This class models an union in description logics.
 
 
This class models an universal restriction in description logics, i.e.
 
*description missing*
This Update-class provides update-elements used within dynamic preference aggregations
The class for event objects used in dynamic preference aggregation
The interface for UpdateListener used for dynamic preference aggregation
This exemplary class implements a simple printer for update events writing its result into the console
Konzeption: Der Update-Stream ist eine Datenstruktur, die benutzt wird, um eine Reihe von Updates fuer dynamische POs einzuspeisen und zu verwalten.
Update Parser for reading updates for dynamic Preference Aggregation Please note: update file syntax changed from (index, operation, amount, element) e.g.
Token literal values and constants.
Token Manager.
This class models an approximation from above to the distance minimization inconsistency measure as proposed in [Thimm,UAI,2009], see [PhD thesis, Thimm].
Generates baseline lottery agents.
 
Objects of this class represent utility function that assess dialogue traces.
This interface models an utility function, i.e.
A utility function that maps divisions to utilities
 
Implements a general vacuous reduct reasoner, as proposed in [Thimm.
example for the vacuous reduct reasoner
ValueIteration<S extends State,A extends Action>
The value iteration algorithm for determining optimal policies
This class represents a single grounding requirement stating that a variable is not allowed to be substituted by a specific constant.
A Variable is a placeholder for Constants in a generic formula of a logic language.
This class models a variable as a mathematical term.
 
This class represents a single grounding requirement stating that two variables are not allowed to be substituted by the same constant.
This class contains some auxiliary methods for working with vectors.
Is used to verify a certain property of an Interpretation, e.g.
Creates an aggregator for veto scoring
A general and easy-to-use interface which allows for type-safe operations on the AcceptanceCondition hierarchy.
 
Reasoner for weak admissibility the reasoner reduces the number of sets we have to check by computing candidate sets instead of checking all sets.
Reasoner for weakly complete semantics as described in: see: Baumann, Brewka, Ulbricht: Revisiting the foundations of abstract argumentation-semantics based on weak admissibility and weak defense.
Reasoner for weakly grounded semantics a set of arguments E is w-grounded iff it is w-complete and minimal Note: unlike the grounded extension which is unique, there can be more than one w-grounded extension see: Baumann, Brewka, Ulbricht: Revisiting the foundations of abstract argumentation-semantics based on weak admissibility and weak defense.
Reasoner for weakly preferred semantics see: Baumann, Brewka, Ulbricht: Revisiting the foundations of abstract argumentation-semantics based on weak admissibility and weak defense.
This class models a weak negation for 3-valued propositional logic as proposed in [Heyninck 2020] Adapted from the class "Negation"
Weak Reinstatement Principle A semantics satisfies weak reinstatement if for all extensions E it holds that: if E strongly defends an argument a, then a is in E An argument a is strongly defended by E iff some argument in E \ {a} defends a see: Baroni, P., and Giacomin, M.
Example usage of the reasoner for weak semantics
*description missing*
*description missing*
 
Minimalistic Implementation of a weighted argumentation theory used for learning argumentation theories from labelings
WeightedEdge<S extends Node,T extends Number>
Interface for weighted edges.
*description missing*
*description missing*
 
This interface is used for
This reasoner for ABA theories performs inference on the ideal extension.
This inconsistency measurement process keeps a window of a number of previous formulas in memory and computes the inconsistency value from this window using an ordinary inconsistency measure.
This class represents an abstract writer for writing objects into the file system.
This class models a z-reasoner for conditional logic.