# 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.

Parses a Assumption Based Argumentation System out of an input text.

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.

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.

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.

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.

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.

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 (\)

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.

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.

This class models a belief set, i.e.

Classes extending this abstract class represent inconsistency measures
on belief sets.

Classes implementing this interface are able to enumerate
belief sets.

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.

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.

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.

A basic interface representing a causal law.

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.

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.

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.

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 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 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].

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.

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

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.

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).

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.

This reasoner performs default dialectical reasoning
on some given DeLP.

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.

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.

This class models the drastic distance measure between interpretations,
see [Grant, Hunter.

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.

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.

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

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 generator generators all possible Dung argumentation theories.

This interface models an environment for agents, i.e.

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.

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.

An abstract kernel for strong equivalence in abstract argumentation frameworks

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.

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.

GameSimulator<S extends AbstractProtocol & GameProtocol,T extends Agent,R extends MultiAgentSystem<T>>

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.

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

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.

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.

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.

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)

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.

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

Listener interface for listeners of stream-based inconsistency measures.

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.

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 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.

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.

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.

This class contains a set of closed set (interval) of possible numbers

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.

P is justifiable wrt.

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

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 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 represents a conjunction in ldo logic.

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.

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.

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.

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): '*'

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

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.

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.

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 exception is thrown when a non-differentiable term
is attempted to be differentiated.

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].

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.

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.

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.

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

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 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.

A policy (map from states to actions) for Markov Decision Process

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.

Models a general (rationality) postulate, i.e.

Classes implementing this interface can be evaluated
wrt.

Summarises the results of a postulate evaluation.

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

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.

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.

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.

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.

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.

- Categorizer [Besnard, Hunter.

Example code for even more ranking semantics:

- Counting Semantics [Pu, Zhang, G.Luo, J.Luo.

- 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.

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.

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.

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.

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

Implements the serialisable ranking semantics from
[Blümel, Thimm.

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

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.

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.

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).

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.

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.

SimulationResult<S extends AbstractProtocol & GameProtocol,T extends Agent,R extends MultiAgentSystem<T>>

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.

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.

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

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.

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}
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.

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.

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.

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 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 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.

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

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

Minimalistic Implementation of a weighted argumentation theory
used for learning argumentation theories from labelings

Interface for weighted edges.

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.

`AbstractDialecticalFramework.query()`

instead