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.
The AbaGetSemanticsResponse class extends the Response class and represents
a response containing information about the supported semantics for Assumption
Based Argumentation (ABA).
Parses an Assumption-Based Argumentation (ABA) System from an input text.
The AbaReasonerCalleeFactory class provides a factory for creating different
instances of Argumentation-Based Argumentation (ABA) reasoner callees based on
specific commands.
Enumeration of supported commands for ABA reasoner.
The AbaReasonerGetModelCallee class extends the Callee class and represents
a callee responsible for obtaining some model from an Argumentation-Based Argumentation (ABA) reasoner.
The AbaReasonerGetModelsCallee class extends the Callee class and represents
a callee responsible for obtaining multiple models from an Argumentation-Based Argumentation (ABA) reasoner.
The AbaReasonerPost class represents a data structure for sending post requests
to an Argumentation-Based Argumentation (ABA) reasoner.
The AbaReasonerQueryCallee class extends the Callee class and represents
a callee responsible for querying an assumption in Argumentation-Based Argumentation (ABA).
The AbaReasonerResponse class extends the Response class and represents the
response
data structure for an Argumentation-Based Argumentation (ABA) reasoner.
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, bundling common methods for mining association rules.
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.
The
AbstractCandidateGenerator is an abstract class that provides a base implementation for generating
candidate interpretations using a SAT solver state.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.
Builder interface for constructing instances of
AbstractDialecticalFramework.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.
The AbstractElementParser class
Abstract extension reasoner for reasoning with extended theories
An abstract class for performing extension analysis on a PEAF (Process-Entity-Attribute-Function) theory.
Ancestor class for all extension-based reasoners.
Main factory for retrieving abstract extension reasoners.
An enumeration of all available semantics.
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.
Abstract extension reasoner for reasoning with recursive extended theories
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.
AbstractTransformer class
This abstract class implements the TweetyPlugin interface and provides a base
for plugin implementations in each project
AbstractUnmodifiableCollection class
This example shows how the different acceptability reasoners work.
An immutable representation of acceptance conditions for ADFs.
Builder class
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, which consists 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 demonstration class for showing how to use the Deductive Argumentation
Framework
with different admissible reasoners.
Kernel AK = (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.
since 1.19, for removal in future versions
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
AFLearner for learning argumentation frameworks from labelingsAn 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.
Allowing abstention principle
Example class demonstrating the use of the PEAF (Preference-based Argumentation Framework) inducer.
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 for probabilistic conditional logic.
Represents the result of an analysis, including performance metrics and analysis type.
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.
Demonstrates the use of exact and approximate justification analysis on a PEAFTheory.
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.
Represents a generic interface for argumentation frameworks in the context of Dung's theory.
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 in the context of 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
Directions
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.
An enum representing optimization functions:
MINIMIZE and
MAXIMIZE.Parser for ASP programs in the ASP-Core-2 syntax
(https://www.mat.unical.it/aspcomp2013/files/ASP-CORE-2.03c.pdf).
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
ASPParserVisitor
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)
in description logic.
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.
AssociativeOperation class
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.
/**
Represents an aggregate node in the abstract syntax tree (AST) for ASP parsing.
ASTAggrElement class
ASTAggrElementList class
class ASTAggrFunc
ASTAnswerSet
ASTAriTerm class
ASTArithop class
ASTBinop class
ASTBody class
ASTBodyList class
ASTBuiltInAtom class
ASTChoice class
ASTChoiceElement class
ASTChoiceElementList class
The
ASTClingoID class represents a node in the abstract syntax tree (AST)
corresponding to a Clingo identifier in the parsing process.The
ASTClingoMeta class represents a node in the abstract syntax tree (AST)
for Clingo meta-statements in the parsing process.The
ASTDlvArithmeticID class represents a node in the abstract syntax tree (AST)
for arithmetic identifiers in the DLV language, a variant of Answer Set Programming (ASP).The
ASTDlvID class represents a node in the abstract syntax tree (AST)
for identifiers in the DLV language, which is a logic programming language used in
Answer Set Programming (ASP).The
ASTHead class represents a node in the abstract syntax tree (AST)
for the head of a rule in the context of Answer Set Programming (ASP).The
ASTHeadElementsList class represents a node in the abstract syntax tree (AST)
for a list of elements that make up the head of a rule in the context of Answer Set Programming (ASP).The
ASTID class represents a node in the abstract syntax tree (AST)
for identifiers within the context of Answer Set Programming (ASP).The
ASTLiteral class represents a node in the abstract syntax tree (AST)
for literals within the context of Answer Set Programming (ASP).The
ASTNAFLiteral class represents a node in the abstract syntax tree (AST)
for literals with negation as failure (NAF) within the context of Answer Set Programming (ASP).The
ASTNAFLiteralList class represents a node in the abstract syntax tree (AST)
for a list of literals that may include negation as failure (NAF) within the context of
Answer Set Programming (ASP).The
ASTNumber class represents a node in the abstract syntax tree (AST)
for numerical values within the context of Answer Set Programming (ASP).The
ASTOpt class represents a node in the abstract syntax tree (AST)
for optimization statements within the context of Answer Set Programming (ASP).The
ASTOptElement class represents a node in the abstract syntax tree (AST)
for an optimization element within the context of Answer Set Programming (ASP).Represents a node in the abstract syntax tree (AST) for an optional element list in the ASP (Answer Set Programming) parser.
The
ASTOptFunc class represents a node in the abstract syntax tree (AST)
for an optimization function within the context of Answer Set Programming (ASP).The
ASTProgram class represents a node in the abstract syntax tree (AST)
for a program in the context of Answer Set Programming (ASP).The
ASTQuery class represents a node in the abstract syntax tree (AST)
for a query in the context of Answer Set Programming (ASP).The
ASTRule class represents a node in the abstract syntax tree (AST)
for a rule in the context of Answer Set Programming (ASP).The
ASTRuleList class represents a node in the abstract syntax tree (AST)
for a list of rules within the context of Answer Set Programming (ASP).The
ASTString class represents a node in the abstract syntax tree (AST)
for string literals within the context of Answer Set Programming (ASP).The
ASTTerm class represents a term node in the abstract syntax tree (AST)
within the context of Answer Set Programming (ASP).The
ASTTermList class represents a node in the abstract syntax tree (AST)
for a list of terms within the context of Answer Set Programming (ASP).The
ASTVar class represents a variable node in the abstract syntax tree (AST)
within the context of Answer Set Programming (ASP).Represents a node in the abstract syntax tree (AST) for a weight in the ASP (Answer Set Programming) parser.
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.
Represents a constraint on attacks within an argumentation framework.
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 are capable of testing
whether a given belief set is consistent.
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
BinaryAcceptanceCondition class
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.
This class implements a SAT encoding for bipolar Abstract Dialectical Frameworks (ADF).
A category for one-class classifiers.
This class represents a Boolean semiring.
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 represents a Bottleneck Semiring.
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
BpmnInconsistencyMeasure class
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
The BpmnSignature class
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.
A generic Callable implementation that throws an UnsupportedOperationException in the call method.
The
CandidateGenerator interface defines a contract for generating interpretations
(candidates) using SAT solvers.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.
This class describes a causal knowledge base.
A basic interface representing a causal law.
This class describes a causal model.
This class describes a causal statement, such as an interventional or counterfactual statement.
This class models a cautious argumentation agent, i.e.
This class implements the inconsistency measure I_CC from
[Said Jabbour and Yue Ma and Badran Raddaoui.
Example code for CF2 semantics.
CF-Reinstatement Principle
This interface provides common methods for change operators
for probabilistic argumentation.
This class demonstrates the use of the
EAFTheory class to check for self-supporting sets of arguments.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
Clause interface represents a logical clause, which is a disjunction (OR) of literals in propositional logic.ClauseSplittingProcessor class
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 class provides a command-line interface for working with Abstract Dialectical Frameworks (ADFs).
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.
Enumeration of factory types for creating instances of
ComparisonCriterion subclasses.Enumeration representing the possible results of a comparison between two
items.
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 CK = (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.
since 1.19, for removal in future versions
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
CompleteVerifier is a verifier class that checks whether a given interpretation
is a complete interpretation within an abstract dialectical framework (ADF).The common abstract class for concepts (also called concepts, complex concepts or concept descriptions)
of description logics.
A complex logical formula can contain arguments referred as terms, this
interface provides methods to substitute and exchange those terms.
Abstract base class for ComplexLogicalFormula, that are formulas which
implement substitute(), exchange(), getTerms(), isGround() and isWellFormed()
and therefore use terms to describe themself.
A complex number.
This class models a concept assertion in description logic, i.e.
This class implements approximate probabilistic justification of a set of queries using Monte Carlo Sampling of
induced EAFs from a PEAF.
This class implements exact probabilistic justification of a set of queries by generating all possible
induces EAFs from a PEAF in parallel.
Instances of this class represent condensed probability distributions, rf.
This class represents a basic conditional (B|A) with formulas A,B.
Represents a conditional structure as introduced in Section 3.5
"Conditionals in Nonmonotonic Reasoning and Belief Revision" of
Gabrielle Kern-Isberner
Internally it saves the data to two nested Maps.
The possible values of a conditional for a possible world
This class builds the initial kappa value list for a given conditional
structure.
ConditionalTaskStep class
ConditionlessTaskStep class
This notion of attack models the confident attack relation.
This notion of attack models the strong rebut relation.
The
Configuration class encapsulates the settings used for SAT solving and parallel execution
in an abstract dialectical framework (ADF) system.The
Builder class for constructing Configuration instances.The
ConflictFreeGenerator is an abstract class responsible for generating conflict-free interpretations
in the context of abstract dialectical frameworks (ADFs).This class implements a SAT encoding for conflict-free interpretations in an Abstract Dialectical Framework (ADF).
The
ConflictFreeMaximizer is an abstract class responsible for maximizing conflict-free
interpretations in an abstract dialectical framework (ADF).Conflict-free Principle
Deprecated, for removal: This API element is subject to removal in a future version.
since 1.19, for removal in future versions
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.
ConjunctionAcceptanceCondition
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.
ContradictionAcceptanceCondition enum
This class provides some utility methods for converting different
data types.
This class bridges the gap between Abstract Dialectical Frameworks (ADFs) and Conditional Logic (CL)
This consistency restorer determines the new probabilities of conditionals
by computing the ME-distribution of each maximal consistent subset of the
knowledge base, then convex combining those yielding a distribution P,
and extracting the new probabilities from P.
This consistency restorer determines the new probabilities of conditionals
by computing the ME-distribution of each single conditional, then convex
combining those yielding a distribution P, and extracting the new probabilities
from P.
For enabling cross-origin resource sharing
This class describes a counterfactual causal statement like:
given phi, if v had been x then rho would be true
Reference: "Argumentation-based Causal and Counterfactual Reasoning" by
Lars Bengel, Lydia Blümel, Tjitze Rienstra and Matthias Thimm, published at
1st International Workshop on Argumentation
for eXplainable AI (ArgXAI, co-located with COMMA ’22), September 12, 2022
This class implements the argument ranking approach of [Pu, Luo,
Ranking Arguments based on Counter-Transitivity 2017].
The solver used to determine the ranking of arguments.
Demonstrates the usage of the
CounterTransitivityReasoner with a specific Argumentation Framework (AAF).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.
Demonstrates how to construct a conditional logic knowledge base programmatically
and query it using the Simple 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.
Handles command-line options related to
ComparisonCriterion objects.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.
This class represents an inconsistency measure based on the count of cycles in an argumentation framework.
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
The DeadEndMeasure
The DeadTransitionMeasure
The
Decomposer interface defines a contract for decomposing an
argumentation framework or a logic system into multiple parts based on a
desired criterion.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.
Demonstrates the construction of deductive argumentation frameworks and the computation of 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, representing
an observation for machine learning tasks.
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).
Defence principle
Deprecated, for removal: This API element is subject to removal in a future version.
This class is no longer used and will be removed in a future version.
An enumeration for the type of degree to be used in comparisons.
The `DelpAnswer` class represents a wrapper around a generic answer from a reasoner,
allowing for an additional state of `UNDECIDED` alongside the traditional `YES` and `NO`.
The `Type` enum represents the possible types of answers: `YES`, `NO`, `UNDECIDED`, and `UNKNOWN`.
This class models a DeLP argument which comprises of a set of defeasible rules (the support) and a literal (the conclusion).
The DeLPCallee class represents a callee for querying a Defeasible Logic Program (DeLP)
using a specified DefeasibleLogicProgram, DelpReasoner, and Formula.
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 interface defines constants used by the `DelpParser` for token
identification and lexical states.
Token Manager.
The DeLPPost class represents a data structure for holding information
related to a Defeasible Logic Program (DeLP) request sent via HTTP POST.
This reasoner performs default dialectical reasoning
on some given DeLP.
The DeLPResponse class extends the Response class and represents
a response containing information related to a Defeasible Logic Program
(DeLP) operation.
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.
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.
Enumeration representing the status of an entity in terms of defeat or victory.
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
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.
DisjunctionAcceptanceCondition class
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.
Calculates the drastic inconsistency measure of the given argumentation framework.It implements the
InconsistencyMeasure interface.
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.
The DungReasonerCalleeFactory class is responsible for creating instances of Callee
based on the specified Command, AbstractExtensionReasoner, and DungTheory parameters.
Enumeration of commands supported by the factory, each with a unique ID and label.
The DungReasonerGetModelCallee class represents a callee for obtaining a model
using a specified AbstractExtensionReasoner and DungTheory.
The DungReasonerGetModelsCallee class represents a callee for obtaining multiple models
using a specified AbstractExtensionReasoner and DungTheory.
The DungReasonerPost class represents a data structure for holding information
related to a Dung argumentation reasoner request sent via HTTP POST.
The DungReasonerResponse class extends the Response class and represents
a response containing information related to a Dung argumentation reasoner
result.
The DungServicesInfoResponse class extends the Response class and represents
a response containing information about Dung argumentation services.
This class captures the signature of a Dung theory,
i.e.
This class implements an abstract argumentation theory in the sense of Dung.
This class lists some parameters
for Dung theory generation.
Class implementing this interface provide the capability
to generate Dung theories.
Example code for generating dung theories and exporting them to apx format.
This class represents a specialization of graph plotters used to visualize argumentation frameworks,
also called @see org.tweetyproject.arg.dung.syntax.DungTheory.
This class summarizes some examples, showcasing the usage of the
DungTheoryPlotter to visualize argumentation frameworks
, also called DungTheory.Creates an aggregator for dynamic veto scoring
A dynamic law in C has the form "caused F if G after U" where F is a
propositional formula over the set of fluent names (called headFormula) G is
a propositional formula over the set of fluent names (called ifFormula) U is
a propositional formula over the set of fluent names and the set of action
names (called afterFormula)
Creates an dynamic aggregator with plurality scoring
This interface is meant to be used for the dynamic aggregation of some generic preference orders
This Demo-class provides a basic implementation similar to the
ScoringPreferenceAggregator but dynamic aggregation instead of static
Creates an dynamic aggregator for veto scoring
Provides an example of constructing an Argumentation Framework (EAFTheory) and saving its representation to a file.
This class implements an abstract argumentation theory in the sense of Evidential Argumentation Frameworks (EAF).
converts EAF to DAF
Provides an example of constructing a Probabilistic Argumentation Framework (PEAFTheory), adding support relationships,
and inducing extensions using a specific inducer.
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 class is responsible for dilating a specified original abstract argumentation framework by adding new arguments and new attacks,
while conserving the original framwork.
This generator generators all possible Dung argumentation theories.
This sampler enumerates all possible propositional belief bases of the given signature.
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.
This interface defines methods for equivalence notions.
The equivalence of first-order logic.
This class models equivalence of propositional logic.
EquivalenceAcceptanceCondition class
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.
Example showcasing the use of different equivalence notions for abstract argumentation frameworks
A strong equivalence kernel for abstract argumentation frameworks, used to characterise strong equivalence wrt.
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
Demonstrates the use of 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
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.
ExclusiveDisjunctionAcceptanceCondition class
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".
Demonstrates the use of various PEAF (Probabilistic Evidential Argumentation Framework)
inducers to compute and display argumentation frameworks and their associated probabilities.
Represents an Extended Attack, i.e., an attack from some argument to another
(extended) attack or argument
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
Implementation of extended argumentation frameworks in the sense of Modgil
Example usage of Extended Argumentation Frameworks
This class models a (possible) extension of a Dung theory, i.e.
An extension of a default theory, i.e.
The `ExtensionAnalysis` interface provides a contract for analyzing and retrieving extensions
in the context of argumentation frameworks, particularly within the domain of bipolar argumentation.
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.
General reasoner for extended theories that computes extended by flattening and then computing the AF extensions
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
Truth values
This class iterates over all 4-valued interpretations of a given signature.
An example demonstrating the use of the FP-Growth algorithm for mining frequent patterns
from a dataset of transactions.
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].
This class represents a Fuzzy Semiring, where elements are interpreted as degrees of
truth in the range [0.0, 1.0].The multiplication operation corresponds to finding the minimum of two weights,
while the addition operation corresponds to finding the maximum, 0.0 represents the
additive identity, and 1.0 represents the multiplicative identity.
Classes implementing this interface represent protocols
for games in the game theoretic meaning.
This class implements a game simulator.
A class to represent gateways of all kinds in a BPMN Model
Possible types of gateways in a BPMN model
Starting from the empty set, this algorithms greedily determines an approximation
to a k-stable extension by iteratively adding arguments (without introducing conflicts) that
add the maximal number of arguments to the range.
This is an abstract generalization over non-flat ABA reasoners.
The GeneralAbaReasonerFactory class is an abstract factory class for creating instances of
Argumentation-Based Argumentation (ABA) reasoners with different semantics.
An enumeration of all available semantics for ABA reasoners.
This abstract class is the common ancestor for semantical approaches to
ranking, i.e.
generalization of CSP
The `GeneralEdge` class represents a general structure for edges in a graph.
The `GeneralGraph` interface represents a general structure for graphs where each graph
consists of nodes and edges.
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!
Starting from the empty set, this algorithms greedily determines an approximation
to a k-stable* extension by iteratively adding arguments that
add the maximal number of arguments to the range, until full range is achieved.
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 GK = (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.
GrounderExample class
GroundGenerator class
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.
since 1.19, for removal in future versions
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
This class provides an example of creating and working with 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.
This class defines 'syntactic' equivalence of
Argumentation Frameworks,
i.e., it checks whether two AFs have exactly the same arguments and attacks.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
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.
ImplicationAcceptanceCondition class
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
Reasoner for incomplete argumentation frameworks
example of a problem for an incomplete reasoner
implementation of incomplete argumentation frameworks
Represents a response object that contains a list of measures related to identified inconsistencies.
Listener interface for listeners of stream-based inconsistency measures.
This interface represents a measure of inconsistency for a Dungian argumentation framework.
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.
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.
Enum representing the status of an
InconsistencyMeasureResult.Represents a data transfer object for inconsistency calculation requests.
An event that is thrown when an inconsistency value
has been updated.
Represents a response object for inconsistency value calculations.
Iterates over all subsets of a given set.
IncrementalSatSolver interface
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
The
IndexedSatSolverState interface represents a state of a SAT solver with indexed literals.This class represents an indicator utility function, i.e.
This class models an individual in description logic, also known as an
object.
This class is responsible for the representation of an
Argument that was induced by a CausalKnowledgeBase
Reference: "Argumentation-based Causal and Counterfactual Reasoning" by
Lars Bengel, Lydia Blümel, Tjitze Rienstra and Matthias Thimm, published at 1st International Workshop on Argumentation
for eXplainable AI (ArgXAI, co-located with COMMA ’22), September 12, 2022This class describes an
abstract argumentation framework that was induced by a CausalKnowledgeBase
Reference "Argumentation-based Causal and Counterfactual Reasoning" by
Lars Bengel, Lydia Blümel, Tjitze Rienstra and Matthias Thimm, published at 1st International Workshop on Argumentation
for eXplainable AI (ArgXAI, co-located with COMMA ’22), September 12, 2022This 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
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 class implements an inconsistency measure for Dung's argumentation frameworks
based on the number of attacks within the framework.
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.
Builder class
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
This class describes an interventional causal statement like:
given phi, if v would be x then rho would be true
Reference: "Argumentation-based Causal and Counterfactual Reasoning" by
Lars Bengel, Lydia Blümel, Tjitze Rienstra and Matthias Thimm, published at
1st International Workshop on Argumentation
for eXplainable AI (ArgXAI, co-located with COMMA ’22), September 12, 2022
Formulas implementing this interface have a
complement
P is involutary wrt.
This class implements the inconsistency measure I_CSP from
[Said Jabbour.
This generator generators all possible Dung argumentation theories
(modulo graph isomorphism).
This reasoner provides is an implementation of the "Iterative Successive Substitution Algorithm"
from [Marco Correia and Jorge Cruz and João Leite.
This class implements the argument ranking approach of
[Grossi, Modgil.
Example code for using the iterated graded semantics from
[Grossi, Modgil.
implements the Iterates local search algorithm
for combinatorial problems
implements the Iterates local search algorithm
for optimization problems
This class implements an example for Tabu search.
This MLN reasoner takes another MLN reasoner and performs several iterations
with this one and takes the average result as result.
Determines utilities iteratively.
Manages the state of the abstract syntax tree (AST) during parsing in the ASP parser.
Generic JSON Object
P is justifiable wrt.
JustificationAnalysisExample class
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.The
KBipolarSatEncoding class provides an encoding of a bipolar argumentation framework into a
propositional formula for SAT solving.The
KBipolarStateProcessor class is responsible for processing the state of an
AbstractDialecticalFramework (ADF) by encoding its bipolar and k-bipolar structure
into logical clauses.This class implements kernel contraction for belief bases [Hansson:2001].
Classes implementing this interface are able to provide kernels (=minimal proofs).
This class implements a KnapSack problem
example for KnapSack via GenOpt
Class implementing an example for a TSP on a cartesian fully connected graph
example for KnaSack via SimAn
Class implementing an example for a TSP on a cartesian fully connected graph
example of KnapSack via Tabu Search
This class describes a knowledge base.
Interface for reasoner capable of optimising k extensions.
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.
KppADFFormatWriter class
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
LanguageException is thrown when an illegal operation is attempted
in a language, such as setting the arity of a propositional predicate to a value greater than zero.Enumeration representing specific reasons why a
LanguageException might be thrown.Fixes the two valued assignments and tries to find a two valued assignment for at least one of the undecided ones.
This class models comparable element ranking by representing the acceptability of
comparable elements in a graph-based structure.
Lazily computes missing values.
This class represents an argument in ldo.
This class implements an argumentation lottery based on the logic of dialectical outcomes,
i.e.
This class captures the common functionalities of formulas with an associative
operation like conjunction, disjunction, etc.
Represents the box modality in the logic of dialectical outcomes (LDO).
This class represents a conjunction in ldo logic.
Represents the diamond modality in the logic of dialectical outcomes (LDO).
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.
Represents the graph box modality in the logic of dialectical outcomes (LDO).
Represents the graph diamond modality in the logic of dialectical outcomes (LDO).
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
Argumentation Framework Learning from Labelings 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 provides an implementation of the `SatSolver` interface using
the Lingeling SAT solver.
Link interface
Interface representing a strategy for determining the type of link between
arguments in a structured argumentation framework.
Enum representing different types of links in a framework.
The
Literal interface represents a logical literal, which can be either a positive or negative
proposition.This class extends the default argumentation reasoner to the reasoning
about literals in the set of arguments constructible from an extended logic program p.
LiThesisPage21EAFExample class
Instances of this class represent application of the logarithm function on some term.
Utility class for configuring a logger with console and file handlers.
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.
MatlabUtils class
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.
A MaxSAT-based implementation for solving the MaxStable* problem from
[Thimm.
A MaxSAT-based implementation for solving the MaxStable problem from
[Thimm.
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].
MeetingPEAFExample class
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.
MinimalModelProvider class
This class models the minimal violation inconsistency measure for the 2-norm.
Repairs a probabilistic belief base by taking the probabilities from the probability function
that minimizes the "minimal violation inconsistency measure" with respect to the euclidean norm.
Repairs a probabilistic belief base by taking the probabilities from the probability function
that minimizes the "minimal violation inconsistency measure" with respect to the euclidean norm.
Repairs a probabilistic belief base by taking the probabilities from the probability function
that minimizes the "minimal violation inconsistency measure" with respect to the euclidean norm.
This class provides a general implementation for the minimal violation inconsistency measure,
cf.
This class models the minimum of two terms.
This approach to consistency restoration follows the approach proposed in [Thimm, DKB, 2011].
Represents the minimum-norm in fuzzy logic, i.e., T(x,y)=min(x,y)
Repairs a probabilistic belief base by taking the probabilities from the probability function
that minimizes the "minimum violation inconsistency measure".
This class provides an implementation of the `SatSolver` interface using
the MiniSat SAT solver.
Class representing Min-Max numberings for labelings of argumentation frameworks
A view that represents the result of subtracting one set from another.
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.
Provides examples of constructing Markov Logic Networks (MLNs) programmatically
and demonstrates how to use coherence measures.
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.
The `MlWriter` class is responsible for writing formulas and belief sets to a specific format.
Helper class providing methods for more efficient computation of models for specific formulae
The
ModelGenerator is an abstract class responsible for generating two-valued model interpretations
in the context of abstract dialectical frameworks (ADFs).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.
since 1.19, for removal in future versions
Modularization Principle
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.
This interface defines a generator for multi-agent systems within a simulation framework.
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
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
NativeMinisatSolver class
NativePicosatSolver class
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.
This represents a negation relation of form
The classical negation of first-order logic.
This class models classical negation of propositional logic.
NegationAcceptanceCondition class
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.
Represents a nested logic program (NLP) in the form of a set of rules.
A rule of a nested logic program.
an interface for a general Node
node interfdace
This exception is thrown when a non-differentiable term
is attempted to be differentiated.
Calculates the non-grounded count inconsistency measure of the given argumentation framework.
Non-Interference Principle
This class represents an example for a non numeric semiring.
Enum representing the elements in the non-numeric semiring: BAD, FAIR, and GOOD.
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 in
dynamic preference aggregation updates.
Illustrates the use of reasoner.KOptimisationReasoner
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.
OptProbElement
This class represents an order among some objects.
OrenEtAl2010Figure2Example class
This class models individual fields used for the PluginOutput.
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.
Pair class
This class implements a simple pair of elements.
ParallelExecution class
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].
Represents the type of transformation to be applied in a logic program or algorithm.
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 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.
This class is capable of restoring consistency of a possible inconsistent probabilistic
conditional belief set.
A perceivable object is some event occuring in an environment and perceivable
by an agent.
This class packs a structured argumentation framework into a
perceivable object.
A class to represent a Petri net
An abstract class for the two types of nodes in a Petri net, places and transitions
A class to map a BPMN model to a Petri net
This class is for displaying instances of the PetriNet class graphically
This class provides an implementation of the `SatSolver` interface using
the PicoSAT SAT solver.
Represents a simple data structure for handling "ping" messages.
A class to describe places in a Petri net
This class represents a knowledge base of propositional formulae.
Some general examples for using basic propositional logic classes like PlParser and SimplePlReasoner.
An Exception for the propositional language, it is thrown if a developer
tries to create illegal propositional statements like a predicate with an
arity greater than zero.
This class represents the common ancestor for propositional formulae.
Implements
RuleFormulaGenerator for propositional logic.This abstract class models a MUS enumerator for propositional logic, i.e.
A class for managing and displaying several plots in a single frame
This class is responsible for the behavior of a plotter with multiple frames.
This class implements a parser for propositional logic.
Manages and creates different parsers for propositional logic.
An enumeration of all available knowledge base formats.
JUnit Test class for PlParser.
Adapted from "PlParser" for the use of 3-valued logic (WeakNegation and Indecision-Operator):
This class provides the JSPF-Plugin for the propositional logic library
Currently plugin is loadable but not executed
A specialized predicate for propositional logic that only allows an identifier
but has no arguments and therefore has an arity of zero.
This class captures the signature of a specific propositional language.
This class provides the output for each plugin to be used in the CLI.
Creates an aggregator with plurality scoring
A window inconsistency measurement process for propositional logic
(this class needs to be there as no generics are allowed when instantiating
a DefaultStreamBasedInconsistencyMeasure.
This class implements a writer for propositional formulas and belief bases.
This class implements the inconsistency measure I_{P_m} proposed in
[Jabbour, Raddaoui.
This class implements the inconsistency measure $I_\pm$ from [Ulbricht,
Thimm, Brewka.
Example code illustrating the Pm inconsistency measure.
The p-norm.
This class is meant to provide a structure to change preference orders and compare the results between changes
This generator generates abstract argumentation frameworks following the schema
described in "Strong Admissibility Revisited" (COMMA2014) by Martin Caminda, following
and idea by Mikolay Podlaszewski.
A policy (map from states to actions) for Markov Decision Process
The `PolicyEvaluation` interface provides methods to evaluate the utility of states
in a Markov Decision Process (MDP) with respect to a given policy.
The policy iteration algorithm for determining optimal policies
A decorator which provides a pool of pre computed
SatSolverState.class Builder
POParser class
Token literal values and constants.
Token Manager.
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.
Represents a generic data structure for HTTP POST requests.
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.
POWriter class
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
PreferencesIntegerBugExample class
The CLI-Plugin for the Preferences-Package
Computes the preferred extension of the given PEAF
This class represents an inconsistency measure based on the count of preferred extensions in a Dung theory.
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.
since 1.19, marked for removal in future versions
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)
The
PreferredVerifier is a verifier class that checks whether a given interpretation is
a preferred interpretation within an abstract dialectical framework (ADF).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
PrimeImplicantTest class
Models a principle for argumentation semantics i.e.
Example code for checking principles for argumentation semantics
This class models the P inconsistency measure from e.g.
This distance function uses an aggregator on a probabilistically normalized distance
for probabilities of each value.
This class implements the probabilistic argumentation framework approach
of [Li, Oren, Norman.
This class represents a probabilistic conditional of the form (B|A)[p]
with formulas A,B and a probability p.
This class implements a probabilistic interpretation for Dung argumentation frameworks, cf.
probablisitic justification analysis
An agent in a game of argumentation lotteries.
Generates lottery agents.
This class implement the p-norm distance function where distances are normalized
corresponding to their distance to 0.5.
Implements a graded semantics reasoner based on the ideas from
[Thimm, Cerutti, Rienstra.
Example code for using the probabilistic ranking reasoner based on the ideas from
[Thimm, Cerutti, Rienstra.
This class represents a probabilistic (Viterbi) Semiring, where elements range between [0.0, 1.0].The addition operation corresponds to finding the maximum, 0.0 represents the
additive identity, and 1.0 represents the multiplicative identity.
Represents the probabilistic sum in fuzzy logic, i.e., S(x,y)=x+y-xy
This class represents a probability, i.e.
This class represents a probability distribution on some logical language
This class represents a probability distribution over some set of objects
This exception is thrown when a problem cannot be solved due to its inconsistency.
This exception is thrown when a problem cannot be solved due to its inconsistency.
This reasoner makes use of an external executable for solving reasoning problems
in abstract argumentation.
This enum contains all supported problems for probo-based reasoner.
The actual computational sub-problem.
This reasoner makes use of an external executable for solving reasoning problems
in abstract argumentation.
Tests parsing and writing functionalities for different formats of Dung's argumentation frameworks
using the AbstractDungParser and AbstractDungWriter within the TweetyProject framework.
A class to represent processes in a BPMN Model
Processor interface
Parse a process in a BPMN model
This class models a product of two terms.
This aggregation function models the product function.
Represents the product-norm in fuzzy logic, i.e., T(x,y)=xy
This class models an ASP-Core-2 program, meaning a set of rules and
optionally a query.
This class implements the argument ranking approach of [Delobelle.
The three propagation semantics:
PROPAGATION1 ("Propa_epsilon")
PROPAGATION2 ("Propa_{1+epsilon}")
PROPAGATION3 ("Propa_{1->epsilon}")
This class represents a simple proposition in propositional logic.
Contains the propositional representation of the arguments and links of some
ADF.
A protocol gives instructions in which order agents have to be asked
for actions in a multi-agent system.
Generates protocols for simulation.
A protocol listener listens on a protocol and is notified whenever an action is executed.
A ProtocolTerminatedException is thrown when
a protocol is asked to perform a step but has already terminated.
Invokes Prover9
( https://www.cs.unm.edu/~mccune/mace4/),
an automated theorem prover for first-order logic, and returns its results.
JUnitTest to test Prover9
Prints single first-order logic formulas and full knowledge bases to Prover9 format
(https://www.cs.unm.edu/~mccune/mace4/manual/2009-11A/).
Some general examples for quantified boolean formulas and for parsers and
writers.
This class implements a parser for quantified boolean formulas.
Examples for using QBF solvers.
Abstract QBF sat solver to be implemented by concrete solvers.
Test class for basic qbf functionalities.
This class represents a possible world of quantified boolean logic, i.e.
This class implements a parser for the QCIR (Quantified CIRcuit) format.
Test class for parsing QCIR files.
This class implements a parser for the QDIMACS input format.
Possible answers that solvers can find for a given QDIMACS problem.
Test class for parsing QDIMACS files.
Converts belief bases to QDIMACS format and prints them.
This class implements a simple quadruple of elements.
This class models a signature as four sets of formulas.
Reasoner for qualified sigma-semantics.
Example on how to use the qualified and semi-qualified semantics reasoners.
This interface represents a general contract for qualitative reasoners, which are objects
that can query a belief base with a specific formula and return a boolean result (`TRUE` or `FALSE`)
based on the reasoning process.
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.
Query class
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.
The
RandomDecomposer is a concrete implementation of the
AbstractDecomposer, designed to randomly partition the arguments
of an AbstractDialecticalFramework (ADF).Generates random Deductive Knowledge Bases.
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.
This sampler generates random belief sets by selecting,
for each formula a random set of possible worlds as its models.
A sampler for uniform random k-SAT instances.
Iterates over all subsets of a given sets in a random order.
A ranking function (or ordinal conditional function, OCF) that maps possible worlds
of a propositional language to integers.
This class is meant to provide ranking functions to given preference orders
and vice versa.
A ranking function (or ordinal conditional function, OCF) that maps possible worlds
of a propositional language to integers.
An abstract postulate for ranking-based semantics in abstract argumentation;
the ancestor of all concrete postulates.
Example code for evaluating ranking semantics in regard to postulates.
Test class for checking counterexamples for some postulates.
Example code for the following ranking semantics:
- Categorizer [Besnard, Hunter.
- 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
ReachabilityGraphParser class
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].
Implementation of argumentation frameworks with recursive attacks in the sense of Baroni et al.
This class provides an example demonstrating the usage of Recursive Extended Argumentation Frameworks
with standard and extended attacks.
Reduct-Admissibility Principle
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.
This class implements a SAT encoding for refining unequal interpretations in an Abstract Dialectical Framework (ADF).
Reinstatement Principle
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.
andles HTTP POST requests at the provided endpoints
Demonstrates the use of resolution-based solvers on Dung argumentation frameworks.
Response placeholder class
This class implements a SAT encoding for restricted bipolar Abstract Dialectical Frameworks (ADF)
based on a given partial interpretation.
The
RestrictedKBipolarSatEncoding class implements a SAT encoding
specifically for restricted bipolar Abstract Dialectical Frameworks (ADFs).The
RestrictedKBipolarStateProcessor is a class that processes SAT encodings for
restricted bipolar and k-bipolar argumentation frameworks.Main class for starting the REST service with Cross-Origin Resource Sharing (CORS) support.
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.
Interface for handling file operations related to formulas.
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.
This class implements a parser for condensed relational probability distributions.
Token literal values and constants.
Token Manager.
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.
Parser for reading and parsing RPCL (Relational Probabilistic Conditional
Logic) probability distributions.
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.
The
SatEncoding interface represents a generic SAT encoding mechanism.Computes the LinkType via two Sat-calls.
SatQueryBuilder class
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)
This class represents the sceptical transformation function
for literals as introduced in [1].
Starting from the complete set of arguments, this algorithms greedily determines an approximation
to a k-stable extension by iteratively removing arguments (that resolve a maximal number of
conflicts) until the set is conflict-free.
Reasoner for SCF2 extensions using scc-recursiveness.
reasoner for SCOOC-naive semantics.
Strong Complete Completeness Outside Odd Cycles Principle (SCOOC)
This class extends the interface for preference aggregation with scoring
Scorings are implemented separately.
The class
ScoringPreferenceAggregatorTest contains tests for the class ScoringPreferenceAggregatorThis 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.
SemanticsStep class
Semi Directionality Principle
P is semi-founded wrt.
P is semi-optimistic wrt.
Semi-Qualified Admissibility Principle
Reasoner for semi-qualified sigma-semantics.
This class represents a generic Semiring, an algebraic structure with two binary operations
(addition and multiplication), and two corresponding identity elements (zeroElement and oneElement).
A class to represent edges of the sequence flow in a BPMN Model
Parse an edge of the sequence flow in a BPMN model
SequentialExecution class
Ancestor class for serialisable AF reasoners
This class summarises examples displaying the usage of
SerialisableExtensionReasoner
for different types of serialisable semantics.Implements the serialisable ranking semantics from
[Blümel, Thimm.
An example class that demonstrates the usage of the
SerialisableRankingReasoner.This class summarizes static methods used to plot serialisability analyses,
consisting of plotting the underlying argumentation framework and the serialisation graphs regarding the specified semantics.
This class defines 'Serialisation' equivalence for
Argumentation Frameworks wrt.A Graph-based representation of the
Serialisation Sequences
of some Argumentation Framework wrt.This class represents a specialization of
GraphPlotters used
to visualize the process of generating extensions by serialising sets of arguments,
as realised in SerialisableExtensionReasoner.Representation of a 'state' in the serialisation process, consisting of the current
DungTheory
and a (partial) Extension.Representation of a serialisation sequence,
i.e., a sequence of initial sets of the respective reducts.
Tests to verify the code in the class
SerialisationSequence.Serialised version of the admissible semantics
Serialised version of the complete semantics
Serialised version of the grounded semantics
Serialised version of the preferred semantics
Serialised version of the stable semantics
This class represents a reasoner to compute the extensions of the strongly admissible
Semantics by serialising unattacked initial sets.Serialised reasoner for the unchallenged semantics
The unchallenged semantics amounts to exhaustively adding unattacked and unchallenged initial sets
This class implements a SetAF in the sense of Nielson/Parson:
This class captures the signature of a SetAf theory,
i.e.
Examples of SetAf Theories 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 implements a set-trie, a data structure for storing sets efficiently.
Starting from the complete set of arguments, this algorithms greedily determines an approximation
to a k-stable* extension by iteratively removing arguments (without losing full range) that
remove the maximal number of conflicts.
This class implements the Shapley culpability measure.
Provides several ways to run unix commands on different OSes.
A signatures lists the atomic language structures for some language.
Classes implementing this interface represent signed culpability measures, i.e.
This implementation of an accumulator simply sums
up the categorizations of the argument trees.
This reasoner for Dung theories performs inference on the admissible extensions.
This reasoner for SetAf theories performs inference on the admissible extensions.
Naive implementation of the iterative algorithm for learning argumentation frameworks from labelings
A simple comparator for Aspic Arguments, that compares their top rules according to a given list of rules
Implementation of the acceptance conditions used for learning argumentation frameworks from labelings
Notation:
for each acceptance condition we also store the argument a it is associated with
In the condition itself we then use !b and b to represent !r_(ba) and r_(ba) respectively
e.g.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
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
Simple reasoner for computing admissible sets of extended theories.
Simple reasoner for computing complete extensions of extended theories.
Simple reasoner for computing conflict-free sets of extended theories.
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.
SimpleGeneticOptimizationSolverCombinatorics class
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
Ref: Yuming Xu and Claudette Cayrol.
The
Initial enum represents the initial status of arguments in a Dung theory.A simple immutable representation of ADF links.
A formula of a logical language
comptes all minimal models given a set of models
This class implements a simple reasoner for MLNs.
This class implements inference for modal logic using a brute-force approach.
enumerates all models naivly
Reasoner for naive extensions.
A simple node of a graph with a name.
A base class representing a node in the abstract syntax tree (AST) for the ASPParser.
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
Represents a simple propositional logic argument in deductive argumentation.
According to
http://www0.cs.ucl.ac.uk/staff/a.hunter/papers/ac13t.pdf
a simple logic knowledge base (propositional version only in this implementation) is
a set of literals---in this implementation rules with empty body---and a set of
simple rules, @see SimplePlRule
Example code for simple logic argumentation.
Parses a simple logic knowledge base out of an input text.
Naive classical inference (checks all interpretations for satisfiability).
Represents a simple propositional logic 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.
Simple reasoner for computing admissible sets of recursive extended theories.
Simple reasoner for computing complete extensions of recursive extended theories.
Simple reasoner for computing conflict-free sets of recursive extended theories.
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 reasoner for weighted Dung theories performs inference on the apha gamma admissible extensions.
This reasoner for weighted Dung theories performs inference on the complete extensions.
This reasoner for weighted Dung theories performs inference on the alpha conflict-free extensions.
This reasoner for weighted Dung theories performs inference on the alpha-gamma-grounded extensions.
This reasoner for weighted Dung theories performs inference on the alpha-gamma-preferred extensions.
This reasoner for weighted Dung theories performs inference on the alpha-gamma-stable extensions.
This class implements the simulated annealing algorithm for combinatrics problems
It is natively implemented
implements the Simulated Annealing algorithm
for optimization problems
This class implements an example for Simulated Annealing on optimization problems.
Objects of this class store additional simulation parameters that
should be shared among the generating components of a simulation.
Instances of this class summarize information
on a performed simulation.
The single peak implementation of the weight vector, where only the highest rated value in each preference order scores
(1,0,0,0,0,0)
This class models a signature as a set of formulas.
SingleValeWeightVector class
This class is capable of restoring consistency of a possible inconsistent probabilistic
conditional belief set.
A function that smoothes two values with a smooting factor, i.e.
This class implements a social abstract argumentation framework from
[Joao Leite, Joao Martins.
Implements a mapping from arguments to social value.
Reasoner for solid admissibility
a set of arguments E solid-defends an argument a, iff for all attackers b of a it holds that
all arguments c which attack b are in E
see: Liu, X., and Chen, W.
This abstract class models an abstract solver for constraint satisfaction or optimization problems.
This class models a generic exception for ASP (Answer Set Programming) solvers.
SomePEAFInducerExample class
A sort of first-order logic.
Invokes SPASS (http://www.mpi-inf.mpg.de/departments/automation-of-logic/software/spass-workbench/),
an automated theorem prover for first-order logic, modal logic and description logics.
Invokes SPASS (http://www.mpi-inf.mpg.de/departments/automation-of-logic/software/spass-workbench/),
an automated theorem prover for first-order logic, modal logic and description logics.
JUnitTest to test SPASS (test cases from
TPTPTest)JUnit Test class for SPASS Prover for modal formulas.
This class prints single first-order logic formulas and knowledge bases to
the SPASS format.
This class prints single first-order modal logic formulas and knowledge bases to
the SPASS format.
This class captures the common functionalities of the special
formulas tautology and contradiction.
This class captures the common functionalities of the special
formulas tautology and contradiction.
Kernel SK = (A, R') for strong equivalence wrt.
This reasoner for ABA theories performs inference on the stable extensions.
Deprecated, for removal: This API element is subject to removal in a future version.
This class is deprecated and scheduled for removal since version 1.19.
a set of arguments S is stable iff it is conflict-free, self-supporting and for any argument a e-supported by bbase,
where a is not in S, S e-support attacks either a or every set of arguments minimally e-supporting a.
a set of arguments S is stable iff the set of arguments deactivated by S equals A\S,
where A is the set of all arguments in the argumentation framework.
Verifies if a given interpretation is stable by comparing it with the ground
interpretation of its omega reduct.
Reasoner for Stage2 semantics using scc-recursiveness
definition see:
Dvorak, Gaggl: Incorporating Stage Semantics in the SCC-recursive Schema for Argumentation Semantics 2012
This class defines 'standard' equivalence for
Argumentation Frameworks wrt.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.
The
StateProcessor interface defines a contract for processing a set of states and
translating them into logical clauses for further operations such as SAT solving or reasoning.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
This notion of attack models the strong attack relation.
This notion of attack models the strong confident attack relation.
This class defines 'Strong' equivalence for
Argumentation Frameworks wrt.Reasoner for strong admissibility
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
TaskStep class
Possible types of tasks in a BPMN model
A tautological formula.
A tautological formula.
TautologyAcceptanceCondition enum
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.
Represents a T-norm in fuzzy logic, i.e., a generalization of a logical
conjunction on values in [0,1].
Describes the input token stream.
Describes the input token stream.
Describes the input token stream.
Describes the input token stream.
Describes the input token stream.
Token Manager Error.
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.
The `Trainer` interface represents a generic trainer that can train a classifier
on a given set of observations and categories.
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
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.
TseitinTransformer class
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.
TwoValuedInterpretationIterator class
This class implements a SAT encoding for two-valued models in an Abstract Dialectical Framework (ADF).
This interface defines method which are given by every TypedStructure like a
Predicate or an Functor.
The abstract parent for predicates and functors implementing the
TypedStructure interface.
This class is capable of restoring consistency of a possible inconsistent probabilistic
conditional belief set.
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.
The UnfairnessEntropyMeasure
The UnfairnessMeasure
This class models an union in description logics.
UnionCollectionView class
A view that provides the union of two disjoint sets as a single set.
This class models an universal restriction in description logics,
i.e.
The UnlivenessMeasure
This class represents an inconsistency measure based on stable extensions.
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.
A lottery agent that selects actions based on a utility function.
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
Utility class providing various helper methods for common operations.
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.Weak Directionality Principle
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
Example usage of the reasoner for weak semantics
* Writes an weighted abstract argumentation framework into a file of the
APX format including the weight value of each attack.
This class implements a weighted abstract argumentation theory (WAF) using a C-Semiring.
Implements an inconsistency measure for Dung's argumentation frameworks based on the weighted count
of connected components within the framework.
This class provides an inconsistency measure for Dung's argumentation frameworks based on the count
and structure of cycles within the framework.
The `WeightedDirectedEdge` class represents a directed edge between two nodes in a graph,
with an associated weight.
Minimalistic Implementation of a weighted argumentation theory
used for learning argumentation theories from labelings
WeightedDungTheoryGeneratorExample class
Interface for weighted edges.
Implements an inconsistency measure for Dung's argumentation frameworks based on the weighted sum of
incoming attacks to each argument.
This class implements an inconsistency measure for Dung's argumentation frameworks
based on the weighted sum of outgoing attacks from each argument.
WeightedReasonerExample class
This class represents a Weighted Semiring, where elements are interpreted as weights or costs.
Implements a customizable weighted Dung theory generator
Represents a weighted support relationship between two argument sets.
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