| AbaAttack<T extends Formula> |
This class models an ABA attack.
|
| AbaElement<T extends Formula> |
Abstract class that models common properties of aba syntax elements.
|
| AbaExample |
Shows some simple code for working with ABA
|
| AbaExtension<T extends Formula> |
This class models an ABA Extension, meaning a set of assumptions.
|
| AbaParser<T extends Formula> |
Parses a Assumption Based Argumentation System out of an input text.
|
| AbaRule<T extends Formula> |
A common interface for assumptions and inference rules.
|
| AbaTest |
Test class for ABA.
|
| AbaTheory<T extends Formula> |
An implementation of Assumption Based Argumentation.
|
| AbsoluteValue |
This class models the absolute value of the inner term.
|
| AbstractAcceptabilityReasoner |
Ancestor class for reasoners that are tailored towards computing the
set {a | a is credulously/skeptically accepted wrt.
|
| AbstractAcceptanceCondition |
|
| AbstractArgumentationExample |
Example code for applying belief dynamics on abstract argumentation frameworks.
|
| AbstractArgumentationInterpretation |
This abstract class acts as a common ancestor for interpretations to
abstract argumentation frameworks.
|
| AbstractAspicReasoner<T extends Invertable> |
The abstract ancestor of all Aspic reasoner implementations
|
| AbstractAssociationRuleMiner<T> |
Abstract layer for association rule miners, bundles common methods.
|
| AbstractBeliefSetConsistencyTester<T extends Formula> |
Classes extending this abstract class are capable of testing
whether a given belief set is consistent.
|
| AbstractBipolarFramework |
This class implements a bipolar abstract argumentation framework with attack and support relations.
|
| AbstractCoherenceMeasure |
This class represents an abstract coherence measure, i.e.
|
| AbstractCollector<U,D,R> |
|
| AbstractConditionalLogicReasoner |
Abstract ancestor for all reasoner for conditional logic.
|
| AbstractCredibilityComparer |
This class provides for auxiliary functions used to compare
formulas and proofs of formulas wrt.
|
| AbstractCreepingMachineShop |
The common ancestor vor creeping machine shops, see [Diss, Thimm] for details.
|
| AbstractDeductiveArgumentationReasoner |
This class contains common characteristics for deductive argumentation
reasoner.
|
| AbstractDialecticalFramework |
The implementing subtypes must ensure the following properties:
Immutability
All methods return a non-null value if its parameters, e.g.
|
| AbstractDialecticalFramework.Builder |
|
| AbstractDialecticalFramework.Signature |
|
| AbstractDialecticalFrameworkReasoner |
Ancestor class for all adf reasoner
|
| AbstractDungParser |
This abstract class gives a template for parsers of files representing
abstract argumentation frameworks.
|
| AbstractDungReasoner |
Ancestor class for all AAF reasoners.
|
| AbstractDungWriter |
Writes an abstract argumentation framework into a file
of a specific format.
|
| AbstractExtensionReasoner |
Ancestor class for all extension-based reasoners.
|
| AbstractGraphLdoModality |
Provides common functionalities for the graph-based modalities in LDO.
|
| AbstractInterpretation<B extends BeliefBase,S extends Formula> |
An abstract interpretation for some logical language.
|
| AbstractLdoModality |
Provides common functionalities for all modalities in LDO.
|
| AbstractLotteryAgent |
An agent in a game of argumentation lotteries.
|
| AbstractMlnReasoner |
This class provides common methods for MLN reasoner.
|
| AbstractMlReasoner |
Abstract modal reasoner to be implemented by concrete reasoners.
|
| AbstractMusEnumerator<S extends Formula> |
Abstract implementation for MUes enumerators.
|
| AbstractOrdering<T> |
This class provides a skeletal implementation of the Ordering
interface, to minimize the effort required to implement this interface. |
| AbstractPAChangeOperator |
Provides common functionality for change operators based on probabilistic semantics.
|
| AbstractPafReasoner |
Abstract anecestor for PAF reasoner.
|
| AbstractPASemantics |
This class bundles common answering behaviour for
probabilistic argumentation semantics.
|
| AbstractPclReasoner |
Abstract class for all PCL reasoners.
|
| AbstractPlReasoner |
Abstract class for propositional logic reasoners.
|
| AbstractProtocol |
A protocol gives instructions in which order agents have to be asked
for actions in a multi-agent system.
|
| AbstractRankingReasoner<R extends ArgumentRanking> |
Common abstract class for ranking reasoners for abstract argumentation.
|
| AbstractRealVectorNorm |
Abstract class for real vector norms.
|
| AbstractRpclSemantics |
This class bundles common answering behaviour for
relational conditional semantics.
|
| AbstractSatExtensionReasoner |
Uses a provided SAT solver to solve reasoning problems in AAFs.
|
| AbstractSocialSemantics<L> |
This is the abstract ancestor of concrete semantics for social
abstract argumentation frameworks, cf.
|
| AbstractTransformer<U,D,R> |
|
| AbstractTweetyPlugin |
This abstract class implements the TweetyPlugin interface and provides a base
for plugin implementations in each project
|
| AbstractUnmodifiableSet<E> |
|
| AcceptabilityReasonerExample |
This example shows how the different acceptability reasoner work.
|
| AcceptanceCondition |
An immutable representation of acceptance conditions for ADFs.
|
| AcceptanceCondition.Builder |
|
| AccEqualityTest |
|
| AccessibilityRelation |
This class models an accessibility relation for Kripke
models.
|
| Accumulator |
Classes implementing this interface represent accumulators in the sense
of Definition 8.11 in
Philippe Besnard and Anthony Hunter.
|
| ActionDescription<T extends CausalLaw> |
This class represents an action description as a set of causal laws.
|
| ActionDescriptionConsistencyTester<T extends CausalLaw> |
Classes implementing this interface are capable of checking whether a given
action description is consistent according to some consistency measurements.
|
| ActionEvent |
An action event encapsulates a multi agent system, an agent in this system, and
an action (which was performed by the agent).
|
| ActionName |
A basic interface representing an action name.
|
| ActionQuery |
This is a basic interface for action queries.
|
| ActionQueryParser |
This class implements a parser for action queries in S.
|
| ActionQuerySatisfactionTester |
Classes implementing this interface are capable of checking whether a
transition system satisfies an action query.
|
| ActionQuerySet<T extends ActionQuery> |
An Action Query Set consists of action queries in a specific query language
and provides some common functionalities for such queries.
|
| ActionSignature |
This class represents an action signature consisting of a set of fluent names
and a set of action names.
|
| ActionSignatureParser |
This class implements a parser for signatures of action descriptions.
|
| Activity |
|
| AdmissibleReasoner |
|
| AdmissibleReasoner |
a set of arguments S is admissible iff it is conflict-free and all elements of S are acceptable wrt.
|
| AdmissibleReasoner |
a set of arguments S is admissible iff it is strongly coherent and defends all of its arguments.
|
| AdmissibleVerifier |
|
| Agent |
An agent is a possibly proactive entity situated in some environment.
|
| AgentGenerator<T extends Agent,S extends MultiAgentSystem<T>> |
This interface defines an agent template that is used to generate
agents following some common characteristics.
|
| AggregateAtom |
This class represents an aggregate.
|
| AggregateElement |
This class models an aggregate element, meaning a set of terms and a set of
naf literals (= literals or default negated literals).
|
| AggregatingCoherenceMeasure |
This coherence measure uses an aggregation function and a distance function
to measure the coherence of an MLN.
|
| AggregatingNorm |
This norm uses an aggregator on the 1-norm distance of each
value.
|
| AggregatingSemantics |
This class implements aggregating semantics due to [Kern-Isberner, Thimm, KR'2010].
|
| AggregationFunction |
This class aggregates a list of doubles to a single double.
|
| AlchemyExample |
Example code illustrating the use of the Alchemy reasoner.
|
| AlchemyMlnReasoner |
This class implements a wrapper for Alchemy in order to
reason with MLNs.
|
| AlwaysQuery |
This class represents an always query in the action query language S.
|
| AnalysisExample |
|
| AnswerSet |
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.
|
| ApacheCommonsCMAESOptimizer |
|
| ApacheCommonsCMAESOptimizerEx |
This class implements an example for the ApacheCommonsCMAESOptimizer
|
| ApacheCommonsCMAESOptimizerTest |
|
| ApacheCommonsNonLinearConjugateGradientOptimizer |
|
| ApacheCommonsNonLinearConjugateGradientOptimizerEx |
This class implements an example for the ApacheCommonsNonLinearConjugateGradientOptimizer
|
| ApacheCommonsSimplex |
This class is a wrapper for the Apache Commons Math Simplex implementation.
|
| ApacheCommonsSimplexEx |
This class implements an example for the Apache Commons SimplexSolver
Version used is 2.0
|
| ApacheCommonsSimplexEx2 |
This class is a second example for the ApacheCommonsSimplexSolver.
|
| ApproximateNaiveMlnReasoner |
This reasoner performs approximate reasoning with MLNs by considering
only a subset of all Herbrand interpretations.
|
| ApproximationExample |
Example code illustrating the use of the sampling-based MLN reasoner.
|
| AprioriMiner<T> |
Implements the classical Apriori algorithm for association rule mining, cf.
|
| AprioriTest |
|
| ApxFilenameFilter |
Filename filter for APX files.
|
| ApxParser |
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.
|
| ApxWriter |
Writes an abstract argumentation framework into a file of the
APX format.
|
| ArguingAgent |
This class represent a general arguing agent with an belief state.
|
| Argument |
An immutable representation of an ADF argument
|
| Argument |
This class models an argument used by Dung's abstract argumentation theory and is just described by its name.
|
| Argument |
Instances of this class represent arguments in the sense
of Definition 2 in [1].
|
| ArgumentationEnvironment |
This class models the environment for agents in argumentation games.
|
| ArgumentationKnowledgeBase |
Instances of this class represent the set of minimal arguments from
a extended logic program
|
| ArgumentationLottery |
This class implements an argumentation lottery, i.e.
|
| ArgumentationReasoner |
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.
|
| ArgumentationReasonerTest |
|
| ArgumentativeRevisionOperator |
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
|
| ArgumentativeSelectiveRevisionTest |
This class implements a comparison application for selective revision
operators using the SimpleRevisionCompare gui.
|
| ArgumentativeTransformationFunction |
This class implements the argumentative transformation functions proposed in [Kruempelmann:2011].
|
| ArgumentDegreeOrdering |
|
| ArgumentDegreeOrdering.DegreeType |
|
| ArgumentRanking |
This abstract class is the common ancestor for semantical approaches to
argument ranking, i.e.
|
| ArgumentSet |
This class models a set of arguments used by bipolar abstract argumentation theory.
|
| ArgumentStatus |
This enumeration enumerates the classical justification status of an argument.
|
| ArgumentStructure |
This class models an argument structure, i.e.
|
| ArgumentTree |
Instances of this class represent argument trees in the sense
of Definition 6.1 in
Philippe Besnard and Anthony Hunter.
|
| ArithmeticTerm |
This class represents an arithmetic term in the ASP-Core-2 format.
|
| ASPAtom |
This class models an atom, which is a basic structure for building literals
and rules for logic programs.
|
| ASPBodyElement |
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.
|
| ASPCore2Constants |
Token literal values and constants.
|
| ASPCore2Parser |
|
| ASPCore2ParserConstants |
Token literal values and constants.
|
| ASPCore2ParserExample |
Examples for parsing simple ELP programs and for using Clingo to solve them.
|
| ASPCore2ParserTest |
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.
|
| ASPCore2ParserTokenManager |
Token Manager.
|
| ASPCore2ParserTreeConstants |
|
| ASPCore2ParserVisitor |
|
| ASPElement |
This class acts as an abstract base class for elements
of ASP rules.
|
| AspFolTranslator |
This Translator can translate between FOL and ASP literals (without default
negated literals).
|
| ASPFOLTranslatorTest |
|
| ASPHead |
This formula represents the head of an disjunctive rule which is a
disjunction of literals.
|
| AspicArgument<T extends Invertable> |
|
| AspicArgumentationTheory<T extends Invertable> |
|
| AspicAttack<T extends Invertable> |
|
| AspicExample |
ASPIC example code.
|
| AspicExample2 |
ASPIC example code.
|
| AspicExampleFol |
ASPIC example code for fol formulas.
|
| AspicGeneratorExample |
Exemplary code illustrating the use of the ASPIC theory generator.
|
| AspicGeneratorExample2 |
This code shows the use of the ASPIC theory generator.
|
| AspicGeneratorExample3 |
This code shows the use of the ASPIC theory generator.
|
| AspicParser<T extends Invertable> |
Parses a Aspic Argumentation System out of an input text.
|
| AspicTest |
|
| AspicWriter<T extends Invertable> |
For writing ASPIC argumentation theories to disk.
|
| AspInconsistencyMeasureTest |
Tests the functionality of PmInconsistencyMeasure
|
| ASPLiteral |
This interface defines common functionality for literals,
meaning atoms or strictly negated atoms.
|
| AspNlpTranslator |
Translates between DLP under the answer set semantics (ASP) and NLP.
|
| ASPNLPTranslatorTest |
|
| ASPOperator |
This class collects some common operators used in ASP terms
as well as the possible function names for aggregates.
|
| ASPOperator.AggregateFunction |
The following aggregate functions are supported by the ASP-Core-2 standard
and by Tweety.
|
| ASPOperator.ArithmeticOperator |
The arithmetic operators that are supported by the ASP-Core-2 standard
and by Tweety.
|
| ASPOperator.BinaryOperator |
The binary comparative operators that are supported by the ASP-Core-2 standard
and by Tweety.
|
| ASPRule |
This class models a rule in ASP.
|
| ASPSolver |
This class provides a common interface for asp solvers.
|
| AssertionalAxiom |
Abstract base class for assertional axioms (concept assertions
and role assertions).
|
| Association |
|
| AssociationRule<T> |
An association rule in item set mining.
|
| AssociationRuleMiner<T> |
Interface for algorithms mining association rules
from transaction databases.
|
| AssociativeDlFormula |
This class captures the common functionalities of description logic associative formulas
(union and intersection).
|
| AssociativeFolFormula |
This class captures the common functionalities first order associative formulas like conjunction,
disjunction, etc.
|
| AssociativeFormula<T extends SimpleLogicalFormula> |
This interfaces describes associative formulas like a disjunction or
a conjunction.
|
| AssociativeFormulaSupport<T extends SimpleLogicalFormula> |
This class provides common implementation for associative formulas that are
formulas which consists of several other formulas.
|
| AssociativeFormulaSupport.AssociativeSupportBridge |
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 |
|
| AssociativePlFormula |
This class captures the common functionalities of formulas with an associative
operation like conjunction, disjunction, etc.
|
| Assumption<T extends Formula> |
This class models an assumption of an ABA theory.
|
| ASTAggregate |
|
| ASTAggrElement |
|
| ASTAggrElementList |
|
| ASTAggrFunc |
|
| ASTAnswerSet |
|
| ASTAriTerm |
|
| ASTArithop |
|
| ASTBinop |
|
| ASTBody |
|
| ASTBodyList |
|
| ASTBuiltInAtom |
|
| ASTChoice |
|
| ASTChoiceElement |
|
| ASTChoiceElementList |
|
| ASTClingoMeta |
|
| ASTHead |
|
| ASTHeadElementsList |
|
| ASTID |
|
| ASTLiteral |
|
| ASTNAFLiteral |
|
| ASTNAFLiteralList |
|
| ASTNumber |
|
| ASTOpt |
|
| ASTOptElement |
|
| ASTOptElementList |
|
| ASTOptFunc |
|
| ASTProgram |
|
| ASTQuery |
|
| ASTRule |
|
| ASTRuleList |
|
| ASTString |
|
| ASTTerm |
|
| ASTTermList |
|
| ASTVar |
|
| ASTWeight |
|
| AsynchronousCloseSatSolverState |
|
| AsynchronousSatSolverState |
Executes all operations of the underlying SatSolverState in a (possibly) separate thread, determined by the provided ExecutorService. |
| Atom |
An atomic language construct, linked to its predicate
|
| Atom.AtomImpl |
Gives common implementations for methods shared among atoms of different types.
|
| Atom.RETURN_SET_PREDICATE |
An enum containing the different return values of the
setPredicate() method of Atom.
|
| AtomicConcept |
This class models an atomic concept (aka concept name) in description logics.
|
| AtomicRole |
This class models a role in description logics.
|
| Attack |
This interface captures common methods of different interpretations of the attack relation in
bipolar abstract argumentation theories.
|
| Attack |
This interface is the common interface for notions of attack between two arguments.
|
| Attack |
This class models an attack between two arguments.
|
| Attack |
This notion of attack models the attack relation.
|
| AttackRelation |
This class represents an attack relation for a specific set
of arguments represented by an ArgumentationKnowledgeBase.
|
| AttackStrategy |
This interface is the common denominator for notions of attack between two arguments.
|
| AttackTest |
|
| AverageAggregator |
This aggregation function models the average function.
|
| AveragingSemantics |
This class implements averaging semantics due to [Kern-Isberner, Thimm, KR'2010].
|
| BalancedMachineShop |
This class implements a consistency restorer using balanced distance minimization, see [Diss, Thimm] for details.
|
| BArgument |
This class models an argument used by bipolar abstract argumentation theories.
|
| BaseContractionOperator<T extends Formula> |
This is the interface for a classic belief base contraction operator, ie.
|
| BaseExpansionOperator<T extends Formula> |
This is the interface for a classic belief base expansion operator, ie.
|
| BaseRevisionOperator<T extends Formula> |
This is the interface for a classic belief base revision operator, ie.
|
| BasicArgument |
This class models a basic argument in structured argumentation frameworks, i.e.
|
| BasicArgumentSampler |
This class implements a formula sampler for structured argumentation
frameworks.
|
| BasicFunctionalityTest |
|
| BeliefBase |
This class captures an abstract knowledge base, i.e.
|
| BeliefBaseMachineShop |
Classes implementing this interface are capable of restoring
consistency of inconsistent belief bases.
|
| BeliefSet<T extends Formula,S extends Signature> |
This class models a belief set, i.e.
|
| BeliefSetConsistencyTester<T extends Formula> |
Classes extending this abstract class are capable of testing
whether a given belief set is consistent.
|
| BeliefSetInconsistencyMeasure<S extends Formula> |
Classes extending this abstract class represent inconsistency measures
on belief sets.
|
| BeliefSetIterator<T extends Formula,U extends BeliefSet<T,?>> |
Classes implementing this interface are able to enumerate
belief sets.
|
| BeliefSetSampler<T extends Formula,U extends BeliefSet<T,?>> |
This abstract class models a random sampler for belief sets.
|
| BeliefState |
This abstract class encapsulates the common characteristics of
a belief state for arguing agents.
|
| BeliefStateConfiguration |
This class encapsulates configuration options for generating
belief states.
|
| BfgsRootFinder |
Implements the BFGS method to find zeros of a (multi-dimensional)
function.
|
| BfgsSolver |
This class implements the BFGS algorithm for solving unconstrained optimization problems.
|
| BfgsSolverEx |
This class implements an example for the BfgsSolver
|
| BinaryAttack |
This class models a binary attack relation between two arguments.
|
| BinaryFunction<T,S,R> |
Encapsulates common methods of mathematical functions with a two parameters.
|
| BinaryRelation<T> |
This abstract class provides a basic implementation of a generic set of pairs to be used for
preference ordering.
|
| BinarySupport |
This class models a support between two arguments.
|
| BinaryVariable |
This class models a binary variable as a mathematical term.
|
| BipolarEntity |
This interface captures common methods of arguments and argument sets of
bipolar abstract argumentation theories.
|
| BipolarSatEncoding |
|
| BooleanCategory |
A category for one-class classifiers.
|
| BordaScoringPreferenceAggregator<T> |
Implementation of the borda scoring preference aggregator
|
| BordaWeightVector |
Implementation of the borda weight vector
N elements are weighted from 0 to n-1 depending on their ranking function rank
|
| BottomConcept |
This class models the bottom concept (empty concept) in description logics.
|
| BoundedSum |
Represents the bounded sum in fuzzy logic, i.e., S(x,y)=min(x+y,1)
|
| BpmnEdge |
|
| BpmnElement |
|
| BpmnFormula |
|
| BpmnModel |
|
| BpmnNode |
|
| BpmnSignature |
|
| BurdenBasedRankingReasoner |
This class implements the "Burden-based" argument semantics approach as
proposed by [Amgoud, Ben-Naim.
|
| CacheMap<K,V> |
Uses the provided function to compute absent values on access, theses values are memorized for future access to avoid further computations.
|
| CActionDescription |
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.
|
| CActionDescriptionConsistencyTester |
This class is able to check, whether 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.
|
| CadetSolver |
|
| CandidateGenerator |
|
| CanonicalIterator |
Provides an iterator on all syntactically equivalent knowledge bases.
|
| CanonicalUndercut |
This attack notion models the canonical undercut relation; A is defeated by B iff claim(B) =- \neg support(A).
|
| CaqeSolver |
|
| Categorizer |
Classes implementing this interface represent categorizer in the sense
of Definition 8.10 in
Philippe Besnard and Anthony Hunter.
|
| CategorizerRankingReasoner |
This class implements the "h-categorizer" argument ranking approach that was
originally proposed by [Besnard, Hunter.
|
| Category |
A category within the space of observations.
|
| CausalLaw |
A basic interface representing a causal law.
|
| CautiousArgumentationAgent |
This class models a cautious argumentation agent, i.e.
|
| CcInconsistencyMeasure<S extends Formula> |
This class implements the inconsistency measure I_CC from
[Said Jabbour and Yue Ma and Badran Raddaoui.
|
| CF2Example |
Example code for CF2 semantics
|
| ChangeOperator |
This interface provides common methods for change operators
for probabilistic argumentation.
|
| ClassicalCategorizer |
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.
|
| ClassicalFormula |
This interface models a classical formula, i.e.
|
| ClassificationTester<S extends Observation,T extends Category> |
Classes implementing this interface provide the means to test a training mechanism
for performance.
|
| Classifier |
A classifier classifies observations into categories.
|
| ClauseSplittingProcessor |
|
| CLaw |
The action description language C consists of two distinct expressions:
static laws and dynamic laws.
|
| CLawParser |
This class implements a parser for causal laws in C.
|
| ClBeliefSet |
This class models a belief set on conditional logic, i.e.
|
| CliMain |
skeleton of the new main method of this CLI using plugins.
|
| ClingoSolver |
Invokes Clingo (Part of the Potassco
project), an ASP system that grounds and solves logic programs, and
returns computed answer sets. |
| ClingoTest |
Test class for Clingo.
|
| ClingoWriter |
|
| ClNLPTranslator |
Translates between propositional Conditionals and NLP.
|
| ClosureReasoner |
a set of arguments S is closed under the support relation iff all arguments supported by an element of S are in S.
|
| ClParser |
This class implements a parser for conditional logic.
|
| CnfParser |
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).
|
| CnfSampler |
A simple sampler for propositional belief bases.
|
| CnfWriter |
Writes an abstract argumentation framework into a file of the
CNF format.
|
| CoherentPASemantics |
P is coherent wrt.
|
| Collector<U,D> |
|
| CombinatoricsProblem |
This class implements a combinatorial optimization problem
|
| CommandLineInterface |
|
| CommandParameter |
This is the abstract basics class for CommandParameter
Never leave identifier and description arguments for the constructor
empty, they can not be changed afterwards
|
| ComparativeAtom |
This class represents a comparative atom, meaning an expression of the form t x u
where t,u are terms and x is in {<, <=, ==, !=, >, >=}.
|
| ComparisonCriterion |
This class is the superclass for all comparison criteria between two arguments in defeasible logic programming.
|
| ComparisonCriterion.Factory |
To select a subclass and create an instance throw a static factory method.
|
| ComparisonCriterion.Result |
|
| CompatibilityMeasure |
This interface represents a compatibility measure for MLNs.
|
| Compilation |
Instances of this class are compilations in the sense of
Definition 8 in
Philippe Besnard and Anthony Hunter.
|
| CompilationNode |
Instances of this class represent nodes in the compilation of
a knowledge base, i.e.
|
| CompilationReasoner |
This class implements the approach of knowledge base compilation as proposed in
Philippe Besnard and Anthony Hunter.
|
| Complement |
This class models the complement (negation) in description logics.
|
| CompleteReasoner<T extends Formula> |
This reasoner for ABA theories performs inference on the complete extensions.
|
| CompleteReasoner |
|
| CompleteReasoner |
a set of arguments S is complete iff it is admissible and all arguments acceptable wrt.
|
| CompleteReasoner |
a set of arguments S is complete iff it is admissible and all arguments defended by S are in S.
|
| CompleteVerifier |
|
| ComplexConcept |
The common abstract class for concepts (also called concepts, complex concepts or concept descriptions)
of description logics.
|
| ComplexLogicalFormula |
A complex logical formula can contain arguments referred as terms, this
interface provides methods to substitute and exchange those terms.
|
| ComplexLogicalFormulaAdapter |
Abstract base class for ComplexLogicalFormula, that are formulas which
implement substitute(), exchange(), getTerms(), isGround() and isWellFormed()
and therefore use terms to describe themself.
|
| ComplexNumber |
A complex number.
|
| ConceptAssertion |
This class models a concept assertion in description logic, i.e.
|
| CondensedProbabilityDistribution |
Instances of this class represent condensed probability distributions, rf.
|
| Conditional |
This class represents a basic conditional (B|A) with formulas A,B.
|
| ConditionalStructure |
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.
|
| ConditionalStructure.Generator |
The possible values of a conditional for a possible world
|
| ConditionalStructureKappaBuilder |
This class builds the initial kappa value list for a given conditional
structure.
|
| ConfidentAttack |
This notion of attack models the confident attack relation.
|
| ConfidentRebut |
This notion of attack models the strong rebut relation.
|
| ConflictFreeGenerator |
|
| ConflictFreeInterpretationSatEncoding |
|
| ConflictFreeReasoner |
|
| ConflictFreeReasoner |
a set of arguments S is conflict-free iff there exists no attack between a subset of S and an element of S.
|
| Conjunctable |
Formulas implementing this interface can be connected by using
AND.
|
| Conjunction |
The classical conjunction of first-order logic.
|
| Conjunction |
This class represents a conjunction in propositional logic.
|
| ConjunctionAcceptanceCondition |
|
| ConsistencyTester<T extends BeliefBase> |
Classes implementing this interface are capable of testing
whether a given belief base is consistent.
|
| ConsistencyWitnessProvider<B extends BeliefBase,S extends Formula> |
Provides methods for returning some model (if it exists) of
a set of formulas.
|
| ConsolidationOperator<T extends Formula> |
This interface represents an consolidation operator for belief bases
as defined in [KKI12].
|
| Constant |
A Constant represents an constant object in the world of
a logical language.
|
| Constant |
This class models an abstract constant, e.g.
|
| ConstraintSatisfactionProblem |
This class models a general constraint satisfaction problem.
|
| ContensionExample |
Example code illustrating the contension inconsistency measure.
|
| ContensionInconsistencyMeasure |
This class implements the contension inconsistency measure, cf.
|
| ContensionInconsistencyMeasurementProcess |
Implements an approximation algorithm for the Contension inconsistency measure on streams.
|
| ContensionSampler |
Generates random propositional belief base with a given
inconsistency measure (for the contension inconsistency measure)
and of a given size.
|
| Contradiction |
A contradictory formula.
|
| Contradiction |
A contradictory formula.
|
| ContradictionAcceptanceCondition |
|
| ConversionTools |
This class provides some utility methods for converting different
data types.
|
| ConvexAggregatingMaxConsMeMachineShop |
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.
|
| ConvexAggregatingMeMachineShop |
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.
|
| CorsResponseFilter |
For enabling cross-origin resource sharing
|
| CountingRankingReasoner |
This class implements the argument ranking approach of [Pu, Zhang, G.Luo,
J.Luo.
|
| CountingUtilityFunction |
This class represents a counting utility function, i.e.
|
| CParser |
This class implements a parser for an Action Description in C.
|
| CReasoner |
This class models a c-reasoner for conditional logic.
|
| CReasonerExample |
|
| CredibilityCategorizer |
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.
|
| CredibilityRevision<T extends Formula> |
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.
|
| CredibilityRevision |
Implements the credibility revision approach for ASP described in
Kruempelmann et al.
|
| CredibilityRevision.AnswersetProcessing |
interface defines a method to process the extended answer sets of the
credibility revision to generate the new ELP.
|
| CredibilityRevision.DefaultBehavior |
This class implements a default behavior for the processing of the answer sets
of the credibility logic programs.
|
| CredibilityRevisionIterative<T extends Formula> |
Implements the list based method of the Revision interface by iterative calling
the revision method which revise two belief bases.
|
| CredibilityRevisionNonIterative<T extends Formula> |
Implements the revision method with two belief bases by delegating the processing
to the revision method bases on an ordered list of belief bases.
|
| CredibilityTest |
Tests the revision method described in Kruempelmann et al.
|
| CriterionOptionHandler |
|
| CrMasArgumentativeRevisionOperator |
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
|
| CrMasBeliefSet<T extends Formula,S extends Signature> |
This class represents belief sets for credibility-based agents multi-agent
systems.
|
| CrMasExample |
Example code on using belief operators in multi-agent settings.
|
| CrMasRevisionWrapper<T extends Formula> |
This class is a wrapper for a revision for formulas of type T that is
used to revise information objects.
|
| CrMasSimpleRevisionOperator |
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.
|
| CrossValidator<S extends Observation,T extends Category> |
Performs cross-validation in a classifier, i.e.
|
| CspInconsistencyMeasure<S extends Formula> |
This class implements the inconsistency measure I_CSP from
[Said Jabbour, Yue Ma, Badran Raddaoui, Lakhdar Sais, Yakoub Salhi.
|
| CspInconsistencyMeasureTest |
|
| CTransitionSystemCalculator |
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: Representing Transition Systems by Logic Programs.
|
| CulpabilityMeasure<S extends Formula,T extends BeliefSet<S,?>> |
Classes implementing this interface represent culpability measures, i.e.
|
| CustomStringListCommandParameter |
This class extends the string list command parameter with functionality
to define valid strings with regular expressions.
|
| CycleCountInconsistencyMeasure<T extends DungTheory> |
|
| CygwinShell |
Cygwin shell.
|
| DalalDistance |
This class models the dalal distance measure between possible worlds,
see e.g.
|
| Deduction<T extends Formula> |
An argument derived from an ABA theory.
|
| DeductiveArgument |
Instances of this class represent arguments in the sense
of Definition 3.1 in
Philippe Besnard and Anthony Hunter.
|
| DeductiveArgumentation |
|
| DeductiveArgumentationFramework |
This class implements a bipolar abstract argumentation theory with support in a deductive sense.
|
| DeductiveArgumentationTest |
|
| DeductiveArgumentNode |
Extends a deductive argument by a unique identifier.
|
| DeductiveEnvironment |
This class models the environment for agents in a game of deductive
argumentation.
|
| DeductiveExample |
For testing purposes.
|
| DeductiveKnowledgeBase |
Instances of this class represent deductive knowledge bases,
i.e.
|
| DefaultBaseExpansionOperator<T extends Formula> |
This class implements the default base expansion operator, ie.
|
| DefaultCompatibilityMeasure |
This class represents the default compatibility measure that uses
a coherence measure.
|
| DefaultCondensedProbabilityDistributionWriter |
This class implements a simple writer for writing condensed probability distributions.
|
| DefaultDungTheoryGenerator |
Implements a customizable Dung theory generator.
|
| DefaultFormulaStream<S extends Formula> |
This class models a default stream on the formulas of a given collection.
|
| DefaultGraph<T extends Node> |
Instance of this class represent graphs with nodes of type T
|
| DefaultificationTest |
|
| DefaultInconsistencyListener |
A simple implementation of an inconsistency listener that simply
prints out each event to standard output.
|
| DefaultMeReasoner |
This class implements a maximum entropy reasoner for probabilistic
conditional logic.
|
| DefaultMultipleBaseExpansionOperator<T extends Formula> |
This class implements the default multiple base expansion operator, ie.
|
| DefaultNegation |
This class represents a default negated literal, i.e.
|
| DefaultNegation |
Implements the default fuzzy negation x -> x-1
|
| DefaultObservation |
A default observation is a vector of double values.
|
| DefaultProbabilityDistributionWriter |
This class implements a simple writer for writing probability distributions.
|
| DefaultProcessTree |
Computes the extensions of a default theory
|
| DefaultRule |
Models a default rule in Reiter's default logic, see [R.
|
| DefaultSequence |
sequence of defaults
|
| DefaultStreamBasedInconsistencyMeasure<S extends Formula> |
Implements a stream-based inconsistency measure on a given class of
inconsistency measurement processes.
|
| DefaultSubsetIterator<T> |
Iterates over all subsets of a given sets.
|
| DefaultTheory |
Models a default theory in Reiter's default logic, see [R.
|
| DefeasibleInferenceRule<T extends Invertable> |
|
| DefeasibleLogicProgram |
This class models a defeasible logic program (DeLP).
|
| DefeasibleRule |
This class models a defeasible rule in defeasible logic programming.
|
| Defeat |
This attack notion models the defeat relation; A is defeated by B iff claim(B) |- \neg support(A).
|
| Defeat |
This notion of attack models the defeat relation.
|
| DefeatingRebuttal |
This attack notion models the defeating rebuttal relation; A is defeated by B iff claim(B) |- \neg claim(A).
|
| DelpAnswer |
Wrapping a generic answer from a reasoner in order to allow UNDECIDED
in addition to the traditional YES and NO.
|
| DelpAnswer.Type |
|
| DelpArgument |
This class models a DeLP argument which comprises of a set of defeasible rules (the support) and a literal (the conclusion).
|
| DeLPExample |
DeLP example code
|
| DelpFact |
This class implements a fact in defeasible logic programming which encapsulates a literal.
|
| DelpParser |
This class implements a parser for defeasible logic programs.
|
| DelpParserConstants |
Token literal values and constants.
|
| DelpParserTokenManager |
Token Manager.
|
| DelpReasoner |
This reasoner performs default dialectical reasoning
on some given DeLP.
|
| DelpRule |
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.
|
| DelpService |
Web service for defeasible logic programming.
|
| Derivation<T extends Rule<?,?>> |
This class models a derivation, i.e.
|
| DfInconsistencyMeasure<S extends Formula> |
This class implements the family of "Measures of the Degree of Inconsistency" from
[Mu,Liu,Jin, Bell.
|
| DfInconsistencyMeasureExample |
Example code illustrating the Df inconsistency measure.
|
| DHitInconsistencyMeasure<T extends Interpretation<B,S>,B extends BeliefBase,S extends Formula> |
This class implements the d-hit inconsistency measure from [Grant, Hunter.
|
| DialecticalTree |
This class implements a node of a dialectical tree from DeLP.
|
| DialecticalTree.Mark |
|
| DialogueTrace<S,T extends java.util.Collection<S>> |
Objects of this class represent traces of dialogue in an argumentation game,
ie.
|
| Difference |
This class models a difference between two terms.
|
| DimacsParser |
Parser a file in Dimacs format into a PlBeliefSet.
|
| DirectDefeat |
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.
|
| DirectedEdge<T extends Node> |
Instances of this class represent directed edges.
|
| DirectGameProtocol |
This class implements a direct protocol for argumentation games.
|
| DirectGameProtocolGenerator |
Creates direct game protocols.
|
| DirectionalAspicReasoner<T extends Invertable> |
Computes a restricted AF by only considering relevant arguments to a query.
|
| DirectionalReasonerTest |
Test runtime of module-based vs.
|
| DirectUndercut |
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.
|
| DiscussionBasedRankingReasoner |
This class implements the "Discussion-based" argument semantics approach as
proposed by [Amgoud, Ben-Naim.
|
| Disjunctable |
Formulas implementing this interface can be connected using
OR.
|
| Disjunction |
The classical disjunction of first-order logic.
|
| Disjunction |
This class represents a disjunction in propositional logic.
|
| DisjunctionAcceptanceCondition |
|
| DistanceMinimizationInconsistencyMeasure |
This class models the distance minimization inconsistency measure as proposed in [Thimm,UAI,2009], extended
by the use of different p-norms.
|
| DistanceMinimizationMachineShop |
This consistency restorer uses the distance minimization inconsistency measure
to restore consistency.
|
| Division |
A pair <P,V> is a division of AAF G w.r.t.
|
| DivisionExample |
Example code for working with divisions
|
| DlAxiom |
The common abstract class for axioms of the description logic ALC.
|
| DlBeliefSet |
This class models a knowledge base for description logics.
|
| DlExample |
Examples for using the description logic syntax classes and parser.
|
| DlInterpretation |
This class models an interpretation for description logics.
|
| DlParser |
This class implements a parser for the description logic ALC (attributive
concept language with complements).
|
| DlParserTest |
JUnit Test class for description logics parser.
|
| DlReasonerTest |
JUnit Test class for NaiveDLReasoner.
|
| DlSignature |
This class models a description logic signature.
|
| DLVSolver |
Wrapper class for the DLV answer set solver command line
utility.
|
| DLVTest |
Test class for DLV.
|
| DMaxInconsistencyMeasure<T extends Interpretation<B,S>,B extends BeliefBase,S extends Formula> |
This class implements the d-max inconsistency measure from [Grant, Hunter.
|
| DoubleCategory |
A category for multi-class classification using a double as identifier.
|
| DrasticDistance<T extends Interpretation<B,S>,B extends BeliefBase,S extends Formula> |
This class models the drastic distance measure between interpretations,
see [Grant, Hunter.
|
| DrasticInconsistencyMeasure<T extends DungTheory> |
|
| DrasticInconsistencyMeasure<S extends Formula> |
This class models the drastic inconsistency measure.
|
| DSumInconsistencyMeasure<T extends Interpretation<B,S>,B extends BeliefBase,S extends Formula> |
This class implements the d-sum inconsistency measure from [Grant, Hunter.
|
| DSumMeasureExample |
|
| DualSetSignature<T,S> |
This class models a signature as two sets of formulas.
|
| DummyAgent |
A dummy agent is an agent that cannot act.
|
| DummyAgentGenerator |
Generates dummy lottery agents.
|
| DummyLotteryAgent |
Audience agents (do nothing) for argumentation games.
|
| DungEntity |
This interface captures common methods of arguments and attacks of
abstract argumentation theories.
|
| DungSignature |
This class captures the signature of a Dung theory,
i.e.
|
| DungTheory |
This class implements an abstract argumentation theory in the sense of Dung.
|
| DungTheoryGenerationParameters |
This class lists some parameters
for Dung theory generation.
|
| DungTheoryGenerator |
Class implementing this interface provide the capability
to generate Dung theories.
|
| DungTheoryGeneratorExample |
Example code for generating dung theories and exporting them to apx format.
|
| DynamicBordaScoringPreferenceAggregator<T> |
Creates an aggregator for dynamic veto scoring
|
| DynamicLaw |
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)
|
| DynamicPluralityScoringPreferenceAggregator<T> |
Creates an dynamic aggregator with plurality scoring
|
| DynamicPreferenceAggregator<T> |
This interface is meant to be used for the dynamic aggregation of some generic preference orders
|
| DynamicScoringPreferenceAggregator<T> |
This Demo-class provides a basic implementation similar to the
ScoringPreferenceAggregator but dynamic aggregation instead of static
|
| DynamicVetoScoringPreferenceAggregator<T> |
Creates an dynamic aggregator for veto scoring
|
| Edge<T extends Node> |
Instances of this class represent abstract edges.
|
| EeeAcceptabilityReasoner |
Implements the EEE approach ("exhaustively enumerate extensions") to
determine the set of acceptable arguments of an AF, cf.
|
| EFOLReasoner |
Invokes E ( http://eprover.org),
an automated theorem prover for first-order logic, and returns its results. |
| ElementOfCombinatoricsProb |
This class implements an element for a combinatorial problem.
|
| ELPBaseRevisionOperator |
This class implements the base revision operator for extended
logic programs as introduced in [KKI12].
|
| ELPLexicographicalComparator |
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.
|
| EmptyCriterion |
This class implements the empty criterion to compare two arguments.
|
| EmptyInterpretation |
|
| EndEvent |
|
| EntropyFunction |
The entropy function.
|
| EntropyNorm<T extends java.lang.Comparable<T>> |
The entropy norm.
|
| EnumeratingDungTheoryGenerator |
This generator generators all possible Dung argumentation theories.
|
| EnumeratingIterator |
|
| Environment |
This interface models an environment for agents, i.e.
|
| EqualityPredicate |
This class models an equality predicate, meaning
a predicate of arity 2 that maps to the identity relation.
|
| EqualsTester |
|
| Equation |
This class represent an equation of two terms.
|
| Equivalence |
The equivalence of first-order logic.
|
| Equivalence |
This class models equivalence of propositional logic.
|
| EquivalenceAcceptanceCondition |
|
| EquivalenceAxiom |
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" with C and D as Concepts.
|
| EtaInconsistencyMeasure<B extends BeliefBase,S extends Formula> |
This class implements the Eta-inconsistency measure, cf.
|
| EvaluateRule |
The evaluate rule tries to evaluate the kappa values by using logical
constraints, therefore the KappaTerm evaluate() methods are called. |
| EvaluationInconsistencyListener |
An inconsistency listener that is apt for doing evaluations on the
performance of an inconsistency measure.
|
| EvaluationTest |
|
| Event |
|
| EventType |
|
| EvidentialAcceptability |
|
| EvidentialArgumentation |
|
| EvidentialArgumentation2 |
|
| EvidentialArgumentationFramework |
This class implements a bipolar abstract argumentation theory with support in an evidential sense.
|
| EvidentialArgumentationTest |
|
| ExcludeSubinterpretationsIterator |
Iterates through all interpretations except the ones equal to or more specific than the provided ones.
|
| ExcludeSubinterpretationsIteratorTest |
|
| ExcludeTwoValuedSubinterpretationsIterator |
Iterates through all two-valued(!) interpretations except the ones equal to
or more specific than the provided ones.
|
| ExcludeTwoValuedSubinterpretationsIteratorTest |
|
| ExclusiveDisjunction |
The exclusive disjunction (XOR) in first-order logic.
|
| ExclusiveDisjunction |
This class represents an exclusive disjunction (XOR) in propositional logic.
|
| ExclusiveDisjunctionAcceptanceCondition |
|
| Executable |
An executable is an action an agent performs within an environment.
|
| ExecutableDungTheory |
This class packs a Dung theory into an executable object.
|
| ExecutableExtension |
This class packs an extension into an executable object.
|
| ExecutableFormulaSet |
This class packs a set of formulas into an executable object.
|
| ExistentialRestriction |
This class models an existential restriction in description logics,
i.e.
|
| ExistsQuantifiedFormula |
Exists-quantified first-order logic formula.
|
| ExistsQuantifiedFormula |
This class represents existential quantification for boolean formulas.
|
| Exp |
This class represents an exponential expression by "e".
|
| ExtendedAbstractDialecticalFramework |
Extended in the sense of the addition of arguments and links to an existing
ADF.
|
| Extension |
This class models a (possible) extension of a Dung theory, i.e.
|
| Extension |
An extension of a default theory, i.e.
|
| ExtensionInconsistencyMeasure |
|
| FbInconsistencyMeasure |
Implements the forgetting-based inconsistency measure from
[Besnard.
|
| FbInconsistencyMeasureTest |
Some examples from
[Besnard.
|
| FileDungTheoryGenerator |
This generator receives a list of files containing Dung theories
and returns those step by step.
|
| FileFormat |
This enum lists all supported file formats.
|
| FileListCommandParameter |
This parameter holds a file-list of possible arguments
|
| FirstOrderLogicPlugin |
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.
|
| FixPartialSatEncoding |
Fixes the already assigned true/false values.
|
| FixPartialTransformer |
Syntactically rewrites the acceptance condition s.t.
|
| FlatAbaReasoner<T extends Formula> |
This class models a reasoner over ABA formulae.
|
| FloatConstant |
This class encapsulates a float as a term.
|
| FloatVariable |
This class models an float variable as a mathematical term.
|
| FluentName |
A basic interface representing a fluent name.
|
| FolAction |
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'.
|
| FolActionName |
This class represents an action name.
|
| FolAtom |
An atom in first-order logic, i.e.
|
| FolBeliefSet |
This class models a first-order knowledge base, i.e.
|
| FolExample |
Some examples for using FolParser and provers.
|
| FolFluentName |
This class represents a fluent name.
|
| FolFormula |
The common abstract class for formulas of first-order logic.
|
| FolFormulaGenerator |
|
| FolParser |
This class implements a parser for first-order logic.
|
| FolParserTest |
JUnit Test class for FolParser.
|
| FOLPropTranslator |
A Translator between the FOL and propositonal logic and vice versa.
|
| FolReasoner |
Abstract FOL Prover to be implemented by concrete solvers
|
| FolSignature |
This class captures the signature of a specific
first-order language.
|
| FolWriter |
Prints out single first-order logic formulas and full knowledge bases.
|
| ForallQuantifiedFormula |
For-All-quantified first-order logic formula.
|
| ForallQuantifiedFormula |
This class represents universal quantification for boolean formulas.
|
| Formula |
A formula is a basic language construct.
|
| FormulaSampler<T extends Formula> |
This abstract class models a sampler for formulas.
|
| FormulaStream<S extends Formula> |
This interface models a stream on formulas.
|
| FoundedPASemantics |
P is founded wrt.
|
| FracAggrFunction |
This is the function 1-\sum_i (1-x_i/i) used e.g in
[Mu,Liu,Jin, Bell.
|
| Fraction |
Instances of this class represent fractions of two terms.
|
| FractionSequenceFunction |
The function 1/x.
|
| FunctionalTerm |
A functional term in a logic language, i.e.
|
| FunctionalTerm |
Instances of this class represent a functional term on some inner term.
|
| Functions<T> |
An abstract class as superclass for two different ranking/leveling functions used to rank elements from preference orders
|
| Functor |
A functor for logic language, i.e.
|
| FuzzyInconsistencyMeasure |
This measure implements the approach presented in [Thimm, Measuring Inconsistency with Many-Valued Logics.
|
| FuzzyInconsistencyMeasureTest |
|
| FuzzyInterpretation |
A fuzzy interpretation for propositional logic.
|
| FuzzyMeasureExample |
|
| FuzzyNegation |
Represents a fuzzy negation, i.e., a generalization of a logical
negation on values in [0,1].
|
| GameProtocol |
Classes implementing this interface represent protocols
for games in the game theoretic meaning.
|
| GameSimulator<S extends AbstractProtocol & GameProtocol,T extends Agent,R extends MultiAgentSystem<T>> |
This class implements a game simulator.
|
| Gateway |
|
| GatewayType |
|
| GeneralAbaReasoner<T extends Formula> |
This is an abstract generalization over non-flat ABA reasoners.
|
| GeneralizedMeMachineShop |
Uses the generalized ME-model of a knowledge base to repair it, cf.
|
| GeneralizedMeReasoner |
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.
|
| GeneralizedSpecificity |
This class implements the generalized specificity criterion used to compare two arguments.
|
| GeneralMathException |
This class is represents a general math exception;
|
| GhostQSolver |
|
| GlpkSolver |
|
| GlpkSolverEx |
This class implements an example for the Glpk Solver
|
| GradientDescent |
This class implements the gradient descent method to
find an optimum.
|
| GradientDescentRootFinder |
Implements the gradient descent method to find zeros of a (multi-dimensional)
function.
|
| GradientDescentSolverEx |
This class implements an example for the Gradient Descent Solver
|
| Graph<T extends Node> |
Common interface for graphs with
nodes of type T
|
| GraphAbstractDialecticalFramework |
Internally represented as a graph-like structure.
|
| GraphExample |
|
| GraphExample2 |
|
| GraphStructureInconsistencyMeasure |
|
| GraphUtil |
This abstract class contains some auxiliary methods for working
with graphs.
|
| GraphUtilTest |
|
| GridSearchParameterLearner<S extends Observation,T extends Category> |
A grid-search approach for learning parameters.
|
| GroundedGameAgentGenerator |
Generates new arguing agents for a grounded game.
|
| GroundedGameGenerator |
Generates grounded games.
|
| GroundedGameProtocol |
This class implements a round robin protocol for the grounded game.
|
| GroundedGameProtocolGenerator |
Creates protocols for a grounded game.
|
| GroundedGameSystem |
This multi-agent system models a grounded dialogue game between
two agents.
|
| GroundedGameSystem.AgentFaction |
The factions of agents in this game.
|
| GroundedGameT1AgentGenerator |
Generates agents of type T1.
|
| GroundedGameT2AgentGenerator |
Generates agents of type T2.
|
| GroundedGameT3AgentGenerator |
Generates agents of type T3.
|
| GroundedGameUtilityFunction |
The grounded game utility function u_a^g.
|
| GroundedReasoner |
the grounded extension of bbase is the least fixed point of the characteristic function.
|
| GroundedReasoner |
the grounded extension of bbase is the least fixed point of the characteristic function.
|
| GroundedTest |
|
| GroundedTest2 |
|
| GrounderStableVerifier |
Verifies if a given interpretation is stable by comparing it with the ground
interpretation of its omega reduct.
|
| GroundGenerator |
|
| GroundingRequirement |
This is a common interface for grounding constraints, which have to be met by
a grounder when calculating possible applications of constants to variables.
|
| GroundingRequirementsParser |
This class parses a list of grounding requirements of the form
REQUIREMENT ("," REQUIREMENT)*
|
| GroundingTools |
This class holds common grounding functionality for causal theories using
first-order formulas.
|
| GroundReasoner |
|
| HCategorizer |
This class implements the h-categorizer from
Philippe Besnard and Anthony Hunter.
|
| HerbrandBase |
The Herbrand base is the set of all possible ground atoms of some
given first-order logic.
|
| HerbrandInterpretation |
A Herbrand interpretation is an interpretation for a first-order signature,
stating all ground atoms that are true in the interpretation.
|
| HessianGradientDescent |
This class implements a gradient descent involving Hessian correction
for solving unconstrained optimization problems.
|
| HessianGradientDescentRootFinder |
Implements the hessiane/gradient descent method to find zeros of a (multi-dimensional)
function.
|
| HessianGradientSolverEx |
This class implements an example for the Hessian Gradient Solver
|
| HoldsQuery |
This class represents a holds query in the action query language S.
|
| HsInconsistencyMeasure<B extends BeliefBase,S extends Formula> |
This class implements the Hitting Set inconsistency measure as proposed in [Thimm, 2014, in preparation].
|
| HsInconsistencyMeasurementProcess |
Implements an approximation algorithm for the Hs inconsistency measure on streams.
|
| HsSampler |
Generates random propositional belief base with a given
inconsistency measure (for the Hs inconsistency measure)
and of a given size.
|
| IaqAcceptabilityReasoner |
Implements the IAQ approach ("iterative acceptability queries") to
determine the set of acceptable arguments of an AF, cf.
|
| IcebergInconsistencyExample |
Example code for the "iceberg" inconsistency measures as described in [De Bona, Hunter.
|
| IcebergInconsistencyMeasure |
This class implements the inconsistency measures proposed in [De Bona,
Hunter.
|
| IcebergInconsistencyMeasure.ConsequenceOperation |
A consequence operation returns parts of knowledge bases.
|
| IdealReasoner<T extends Formula> |
This reasoner for ABA theories performs inference on the ideal extension.
|
| ImAdjunctionInvariance |
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.
|
| ImAttenuation |
The "attenuation" postulate for inconsistency measures: Minimal inconsistent
sets of smaller size should have a larger inconsistency value.
|
| ImConsistency |
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.
|
| ImContradiction |
The "contradiction" postulate for inconsistency measures: A knowledge base
is maximally inconsistent if all non-empty subsets are inconsistent.
|
| ImDominance |
The "dominance" postulate for inconsistency measures: Substituting a
consistent formula by a weaker formula should not increase the inconsistency
value.
|
| ImEqualConflict |
The "equal conflict" postulate for inconsistency measures: Minimal inconsistent subsets
of the same size should have the same inconsistency value.
|
| ImExchange |
The "exchange" postulate for inconsistency measures: Exchanging consistent parts
of a knowledge base with equivalent ones should not change the inconsistency value.
|
| ImFreeFormulaDilution |
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.
|
| ImFreeFormulaIndependence |
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.
|
| ImIrrelevanceOfSyntax |
The "irrelevance of syntax" postulate for inconsistency measures: Knowledge
bases with pairwise equivalent formulas should receive the same inconsistency
value.
|
| ImMINormalization |
The "MI-normalization" postulate for inconsistency measures: The inconsistency
value of any minimal inconsistent subset is 1.
|
| ImMISeparability |
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.
|
| ImMonotony |
The "monotony" postulate for inconsistency measures: Adding information
to a belief base cannot decrease the inconsistency value.
|
| ImNormalization |
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.
|
| ImPenalty |
The "penalty" postulate for inconsistency measures: Adding a formula that participates
in an inconsistency (i.e.
|
| Implication |
The implication of first-order logic.
|
| Implication |
This class models the implication of propositional logic.
|
| ImplicationAcceptanceCondition |
|
| ImPostulate |
An abstract postulate for inconsistency measures in propositional
logic; the ancestor of all concrete postulates.
|
| ImPostulateEvaluationExample |
Example code illustrating automatic postulate evaluation of
inconsistency measures.
|
| ImprovedRiveretTheoryLearner |
Implementation of the algorithm for learning (grounded) labelings from with some improvements:
Riveret, Régis, and Guido Governatori.
|
| ImSafeFormulaIndependence |
The "safe-formula independence" postulate for inconsistency measures: Removing a safe
formula (i.e.
|
| ImSuperAdditivity |
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.
|
| ImWeakDominance |
A weaker variant of the "dominance" postulate using prime implicates,
proposed in [Jabbour et al.
|
| IncisionFunction<T extends Formula> |
This interface models an incision function for kernel contraction, ie
a function that incises each of the kernel sets of some set.
|
| InconsistencyListener |
Listener interface for listeners of stream-based inconsistency measures.
|
| InconsistencyMeasure<T extends DungTheory> |
|
| InconsistencyMeasure<T extends BeliefBase> |
Classes implementing this interface represent inconsistency measures
on belief bases.
|
| InconsistencyMeasureFactory |
Main factory for retrieving inconsistency measures for propositional logic.
|
| InconsistencyMeasureFactory.Measure |
An enumeration of all available inconsistency measures.
|
| InconsistencyMeasurementProcess<S extends Formula> |
The actual process of an inconsistency measure on streams.
|
| InconsistencyMeasurementService |
Inconsistency measurement service.
|
| InconsistencyUpdateEvent |
An event that is thrown when an inconsistency value
has been updated.
|
| IncreasingSubsetIterator<T> |
Iterates over all subsets of a given set.
|
| IncrementalSatSolver |
|
| IndicatorUtilityFunction |
This class represents an indicator utility function, i.e.
|
| Individual |
This class models an individual in description logic, also known as an
object.
|
| InequalityPredicate |
This class models an inequality predicate, meaning
a predicate of arity 2 that maps to the complement of the identity relation.
|
| Inequation |
This class models an inequation of two terms.
|
| InferenceMode |
Enum constants for the two classical inference models of skeptical inference (assess
a formula as true iff it is contained in every model) and credoulous inference
(assess a formula as true iff it is contained in some model).
|
| InferenceRule<T extends Formula> |
This class models an inference rule from an ABA theory.
|
| InferenceRule<T extends Invertable> |
|
| InformationObject<T extends Formula> |
This class represents a formula annotated with the source of the formula.
|
| InstanceAssignment |
Instances of this class represent assignenment of true instances for a given
predicate wrt.
|
| InstantiateVisitor |
This visitor iterates over the AST generated by ASPCore2Parser and allocates
classes representing the different parts of an ASP program or source file,
meaning rules, literals, terms, answer sets, etc.
|
| InSumInconsistencyMeasure<T extends DungTheory> |
|
| IntegerCommandParameter |
This parameter holds a number-interval of possible arguments
|
| IntegerConstant |
This class encapsulates an integer as a term.
|
| IntegerVariable |
This class models an integer variable as a mathematical term.
|
| IntermediateEvent |
|
| InterpolantEnumerator<S extends Formula> |
Interface for classes enumerating (Craig) interpolants.
|
| Interpretation |
This class represents a three-valued interpretation of an Abstract
Dialectical Framework (ADF).
|
| Interpretation<B extends BeliefBase,S extends Formula> |
An interpretation for some logical language.
|
| Interpretation.Builder |
|
| InterpretationDistance<T extends Interpretation<B,S>,B extends BeliefBase,S extends Formula> |
Classes implementing this interface represent distance functions
between two interpretations.
|
| InterpretationIterator |
Creates all possible interpretations while respecting the order of the given arguments.
|
| InterpretationIterator<S extends Formula,B extends BeliefBase,T extends Interpretation<B,S>> |
An iterator over interpretations.
|
| InterpretationIteratorTest |
|
| InterpretationProcessor |
Performs further processing on interpretations, e.g.
|
| InterpretationSet<T extends Formula,B extends BeliefBase,S extends Formula> |
This class models an interpretation that is a set of some formula and as such
implements the java.util.Collection interface.
|
| Intersection |
This class models an intersection in description logics.
|
| Interval<S extends java.lang.Number> |
This class contains a set of closed set (interval) of possible numbers
|
| Invertable |
Formulas implementing this interface have a
complement
|
| InvolutaryPASemantics |
P is involutary wrt.
|
| IsInconsistencyMeasure<S extends Formula> |
This class implements the inconsistency measure I_CSP from
[Said Jabbour.
|
| IsoSafeEnumeratingDungTheoryGenerator |
This generator generators all possible Dung argumentation theories
(modulo graph isomorphism).
|
| IssReasoner |
This reasoner provides is an implementation of the "Iterative Successive Subsitution Algorithm"
from [Marco Correia and Jorge Cruz and João Leite.
|
| IteratedGradedDefenseReasoner |
This class implements the argument ranking approach of
[Grossi, Modgil.
|
| IteratedGradedDefenseReasonerExample |
Example code for using the iterated graded semantics by Grossi/Modgil
|
| IteratingMlnReasoner |
This MLN reasoner takes another MLN reasoner and performs several iterations
with this one and takes the average result as result.
|
| JJTASPCore2ParserState |
|
| JustifiablePASemantics |
P is justifiable wrt.
|
| KappaMin |
This class represents a minimum, its elements are KappaTerm instances although
in c-representation this are sums of Kappas KappaSum. |
| KappaSum |
This constructs represents a sum of kappa values (or terms).
|
| KappaTerm |
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.
|
| KappaValue |
|
| KBipolarSatEncoding |
|
| KBipolarStateProcessor |
|
| KernelContractionOperator<T extends Formula> |
This class implements kernel contraction for belief bases [Hansson:2001].
|
| KernelProvider<T extends Formula> |
Classes implementing this interface are able to provide kernels (=minimal proofs).
|
| KnapSack |
|
| KnapSacktester |
|
| KppADFFormatParser |
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.
|
| KppADFFormatParserTest |
|
| KripkeModel |
This class models a Kripke model, i.e.
|
| Labeling |
This class models a labeling of an abstract argumentation framework, i.e.
|
| LagrangeSolver |
This class implements a (naive) Langrange solver for optimization problems.
This solver only considers optimization problems without inequations.
|
| LagrangeSolverEx |
This class implements an example for the Lagrange Solver
it is natively implemented
|
| LagrangeSolverEx2 |
|
| Lane |
|
| LanguageException |
A language exception is thrown if something illegal is tried in a language
like setting the arity of a propositional predicate > zero.
|
| LanguageException.LanguageExceptionReason |
|
| LargerInterpretationSatEncoding |
Fixes the two valued assignments and tries to find a two valued assignment for at least one of the undecided ones.
|
| LastLinkOrder<T extends Invertable> |
|
| LatticeArgumentRanking |
This class models argument ranking by representing the acceptability of
arguments in a graph-based structure.
|
| LazyMap<K,V> |
Lazily computes missing values.
|
| LdoArgument |
This class represents an argument in ldo.
|
| LdoArgumentationLottery |
This class implements an argumentation lottery based on the logic of dialectical outcomes,
i.e.
|
| LdoAssociativeFormula |
This class captures the common functionalities of formulas with an associative
operation like conjunction, disjunction, etc.
|
| LdoBoxModality |
|
| LdoConjunction |
This class represents a conjunction in ldo logic.
|
| LdoDiamondModality |
|
| LdoDisjunction |
This class represents a disjunction in ldo logic.
|
| LdoFormula |
This abstract class specifies the general methods of all Ldo-formulas
(LDO - Logic of dialectical outcomes, cf.
|
| LdoGraphBoxModality |
|
| LdoGraphDiamondModality |
|
| LdoInterpretation |
This class models an LDO interpretation, i.e., a pair
of an argumentation framework and (possibly) an extension.
|
| LdoNegation |
This class models classical negation of ldo logic.
|
| LdoRelation |
Creates a relational formula, i.e.
|
| LdoUtilityFunction |
A utility function that maps LDO formulas to utilities
|
| LearningExample |
|
| LevelingFunction<T> |
This class is meant to provide leveling functions to given preference orders
and vice versa.
|
| LeviBaseRevisionOperator<T extends ClassicalFormula> |
This class implements the Levi identity for revision, ie.
|
| LeviMultipleBaseRevisionOperator<T extends ClassicalFormula> |
This class implements the Levi identity for multiple revision, ie.
|
| LexicographicDoubleTupleComparator |
Compares two double vectors according to the lexicographic ordering.
|
| LexicographicIntTupleComparator |
Compares tuples of integers according to the lexicographic ordering as described in
[Cayrol, Lagasquie-Schiex.
|
| LingelingExample |
|
| LingelingSolver |
A wrapper for the Lingeling SAT solver
(tested with Lingeling version ats1 ce8c04fc97ef07cf279c0c5dcbbc7c5d9904230a).
|
| Link |
|
| LinkStrategy |
|
| LinkType |
|
| LinkTypeTest |
|
| LiteralReasoner |
This class extends the default argumentation reasoner to the reasoning
about literals in the set of arguments constructible from an extended logic program p.
|
| Logarithm |
Instances of this class represent application of the logarithm function on some term.
|
| LogicalSymbols |
This class provides some String constants for logical symbols and allows to
modify them at runtime.
|
| LogicProgram<C extends Formula,P extends Formula,T extends Rule<?,?>> |
An interface for a logic program, which is a set of rules.
|
| LogicStructure |
This interface captures the common functionalities of formulas,
sorts and terms.
|
| LogicStructure |
This abstract class captures the common functionalities of both
formulas and terms.
|
| LotteryArgumentationEnvironment |
This class models the environment for agents in argumentation games with lotteries.
|
| LotteryDialogueTest |
|
| LotteryDialogueTest2 |
Main class for empirical evaluation in [Hunter, Thimm.
|
| LotteryExample |
Example code for working with lotteries in probabilistic abstract argumentation.
|
| LotteryGameGenerator |
Generates lottery games.
|
| LotteryGameSystem |
This multi-agent system models a lottery dialogue game between
a lottery agent and a dummy agent
|
| LowerApproxDistanceMinimizationInconsistencyMeasure |
This class models an approximation from below to the distance minimization inconsistency measure as proposed in [Thimm,UAI,2009], see [PhD thesis, Thimm].
|
| LpSolve |
This class implements a wrapper to the lpsolve binary
for mixed integer linear programming.
|
| LpSolverEx |
This class implements an example for the Genetic LpSolver
it uses LpSolve Version 5.5.2.5 (https://sourceforge.net/projects/lpsolve/)
|
| LukasiewiczNorm |
Represents the Lukasiewicz-norm in fuzzy logic, i.e., T(x,y)=max(x+y-1,0)
|
| MaInconsistencyMeasure<S extends Formula> |
This class models the I_M inconsistency measure from e.g.
|
| MaMeasureExample |
|
| ManhattanNorm |
The Manhattan norm.
|
| MapTools<E,F> |
This class provides some utility functions for maps.
|
| MarcoMusEnumerator |
Implements a MUs enumerator based on MARCO (http://sun.iwu.edu/~mliffito/marco/).
|
| MarkovLogicNetwork |
Instances of this class represent Markov Logic Networks [Domingos et.
|
| MathTools |
This class contains some useful math tools.
|
| MatlabUtils |
|
| Matrix |
This class models a matrix of terms.
|
| MaxAggregator |
This aggregation function models the maximum function.
|
| MaxFunction |
The maximum function.
|
| MaximizeInterpretationProcessor |
Maximizes the given interpretation and afterwards restricts the search space
from generating smaller ones.
|
| Maximum |
This class models the maximum of two terms.
|
| MaximumCoNorm |
Represents the maximum-conorm in fuzzy logic, i.e., S(x,y)=max(x,y)
|
| MaximumEntropyMachineShop |
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.
|
| MaximumNorm |
The Maximum norm.
|
| MaxSatExample |
Illustrates the use of MaxSAT solvers.
|
| MaxSatSolver |
Provides a generic class for implementing MaxSAT solvers, i.e.
|
| McscInconsistencyMeasure<S extends Formula> |
This class implements the approach of [Meriem Ammoura, Badran Raddaoui, Yakoub Salhi, Brahim Oukacha.
|
| McscInconsistencyMeasureExample |
|
| MeanDistanceCulpabilityMeasure |
This class implements the mean distance culpability measure, see [PhD thesis, Thimm].
|
| Message |
|
| MessageFlow |
|
| MicInconsistencyMeasure<S extends Formula> |
This class models the MI^C inconsistency measure.
|
| MiInconsistencyMeasure<S extends Formula> |
This class models the MI inconsistency measure.
|
| MimusMusEnumerator |
Implements a MUs enumerator based on MIMUS (http://www.cs.qub.ac.uk/~kmcareavey01/mimus.html).
|
| MinAggregator |
This aggregation function models the minimum function.
|
| MinimalInconsistentSubsetExample |
|
| MinimalViolation2InconsistencyMeasure |
This class models the minimal violation inconsistency measure for the 2-norm.
|
| MinimalViolationEuclideanMachineShop |
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.
|
| MinimalViolationEuclideanMachineShopOjAlgoExpression |
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.
|
| MinimalViolationEuclideanMachineShopOjAlgoMatrix |
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.
|
| MinimalViolationInconsistencyMeasure |
This class provides a general implementation for the minimal violation inconsistency measure,
cf.
|
| MinimalViolationInconsistencyMeasureLPSolveTest |
|
| Minimum |
This class models the minimum of two terms.
|
| MinimumAggregatedDistanceMachineShop |
This approach to consistency restoration follows the approach proposed in [Thimm, DKB, 2011].
|
| MinimumNorm |
Represents the minimum-norm in fuzzy logic, i.e., T(x,y)=min(x,y)
|
| MinimumViolationMachineShop |
Repairs a probabilistic belief base by taking the probabilities from the probability function
that minimizes the "minimum violation inconsistency measure".
|
| MinusSetView<E> |
|
| MiSampler |
Generates random propositional belief base with a given
inconsistency measure (for the MI inconsistency measure)
and of a given size.
|
| MlBeliefSet |
This class models a modal knowledge base, i.e.
|
| MleanCoPReasoner |
Invokes MleanCoP ( http://www.leancop.de/mleancop/), a compact automated theorem prover
for modal first-order logic based on the clausal connection calculus. |
| MleanCoPTest |
JUnit Test class for MleanCoP.
|
| MleanCoPWriter |
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): '*'
|
| MlExample |
Some examples for testing ModalParser and NaiveModalReasoner
|
| MlExample2 |
More examples for testing ModalParser and ModalReasoner
|
| MlFormula |
This class models a modal formula, i.e.
|
| MlHerbrandBase |
Modified version of HerbrandBase that allows for modal formulas.
|
| MlHerbrandInterpretation |
Modified version of HerbrandInterpretation that allows for modal formulas.
|
| MlnExample |
Shows how MLNs can be constructed programmatically and shows how coherence measures can be used.
|
| MlnExample2 |
Gives further examples on how MLNs can be constructed programmatically and how coherence measures can be used.
|
| MlnFormula |
Instances of this class represent first-order formulas with a weight.
|
| MlParser |
This class implements a parser for modal logic.
|
| MlParserTest |
JUnit Test class for ModalParser.
|
| MlReasonerTest |
JUnit Test class for NaiveModalReasoner.
|
| MlWriter |
|
| ModelGenerator |
|
| ModelProvider<S extends Formula,B extends BeliefBase,T extends Interpretation<B,S>> |
Instances of this interface model reasoners that determine the (selected) models
for a given set of formulas.
|
| ModelReasoner |
|
| ModuleBasedAspicReasoner<T extends Invertable> |
Slightly optimised reasoner for ASPIC.
|
| MonotoneGlobalMaxichoiceSelectionFunction |
This class implements a monotone global maxichoise selection function
for remainder sets of extended logic programs as introduced in [KKI12].
|
| MonteCarloPafReasoner |
This class implements the Monte Carlo algorithm for estimating
probabilities of extensions in probabilistic argumentation frameworks
from [Li, Oren, Norman.
|
| MTRankingReasoner |
This class implements the argument ranking approach of [Matt, Toni.
|
| MultiAgentSystem<T extends Agent> |
A multi-agent system is a collection of agents with some environment.
|
| MultiAgentSystemGenerator<T extends Agent,S extends MultiAgentSystem<T>> |
|
| MultiClassRbfTrainer |
Trains a standard multi-class RBF support vector machine.
|
| MultipleBaseContractionOperator<T extends Formula> |
This is the interface for a classic multiple belief base contraction operator, ie.
|
| MultipleBaseExpansionOperator<T extends Formula> |
This is the interface for a classic multiple belief base expansion operator, ie.
|
| MultipleBaseRevisionOperator<T extends Formula> |
This is the interface for a classic multiple belief base revision operator, ie.
|
| MultipleIndicatorUtilityFunction |
This class represents a multiple indicator utility function, i.e.
|
| MultipleSelectiveRevisionOperator<T extends Formula> |
This class implements a multiple selective revision operator following [Kruempelmann:2011,Ferme:1999].
|
| MultipleTransformationFunction<T extends Formula> |
This interface represents a multiple transformation function for selective revision [Kruempelmann:2011,Ferme:1999].
|
| MusEnumerator<S extends Formula> |
Interface for classes enumerating MUSes (minimal unsatisfiable sets) and
MCSs (maximal consistent sets).
|
| MusExample |
|
| MusVarInconsistencyMeasure |
This class implements the "MUS-variable based inconsistency measure" proposed in
[Xiao,Ma.
|
| NaiveDlReasoner |
Naive reasoner for the description logic ALC (as represented by this library).
|
| NaiveLiteralTransformationFunction |
This class represents the naive transformation function
for literals as introduced in [1].
|
| NaiveLiteralTransformationFunctionTest |
|
| NaiveMusEnumerator<S extends Formula> |
A simple approach to compute minimal inconsistent subsets and maximal
consistent subsets by exhaustive search.
|
| NaiveQbfReasoner |
Naive classical inference for quantified boolean formulas (checks all interpretations for satisfiability).
|
| NaiveReasoner |
|
| NaiveReasoner |
Reasoner for naive extensions.
|
| NativeLingelingSolver |
Experimental lingeling binding
|
| NativeMinisatSolver |
|
| NativePicosatSolver |
|
| NativeShell |
Default shell
|
| NConsInconsistencyMeasure<S extends Formula> |
This class implements an inconsistency measure based on "n-consistency" proposed in
[Doder,Raskovic,Markovic,Ognjanovic.
|
| NecessarilyQuery |
This class represents a necessarily query in the action query language S.
|
| Necessity |
This class models the necessity modality.
|
| NecessityArgumentation |
|
| NecessityArgumentationFramework |
This class implements a bipolar abstract argumentation framework with necessities.
|
| NecessityArgumentationTest |
|
| Negation<T extends Formula> |
|
| Negation |
The classical negation of first-order logic.
|
| Negation |
This class models classical negation of propositional logic.
|
| NegationAcceptanceCondition |
|
| NestedLogicProgramException |
NestedLogicProramException encapsulates those LanugageException that occur
in nested logic programs.
|
| NeutralPASemantics |
P is neutral wrt.
|
| NewtonRootFinder |
This class implements the Newton method for finding zeros of a function.
|
| NicePossibleWorld |
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.
|
| NLPNot |
A default negation of a first order formula, nested logic programs
only allow not quantified formulas.
|
| NLPProgram |
A nested logic program
|
| NLPRule |
A rule of a nested logic program.
|
| NLPRuleTest |
|
| Node |
|
| Node |
|
| NonDifferentiableException |
This exception is thrown when a non-differentiable term
is attempted to be differentiated.
|
| NonGroundedCountInconsistencyMeasure<T extends DungTheory> |
|
| Norm<T> |
A norm for vector spaces.
|
| NormalizedDistanceMinimizationInconsistencyMeasure |
This class models the normalized distance minimization inconsistency measure, see [PhD thesis, Thimm].
|
| NormalizedLowerApproxDistanceMinimizationInconsistencyMeasure |
This class models a normalized approximation from below to the distance minimization inconsistency measure as proposed in [Thimm,UAI,2009], see [PhD thesis, Thimm].
|
| NormalizedMicInconsistencyMeasure<S extends Formula> |
This class models the normalized MI^C inconsistency measure, see [PhD thesis, Thimm].
|
| NormalizedMiInconsistencyMeasure<S extends Formula> |
This class models the normalized MI inconsistency measure, see [PhD thesis, Thimm].
|
| NormalizedUpperApproxDistanceMinimizationInconsistencyMeasure |
This class models a normalized approximation from above to the distance minimization inconsistency measure as proposed in [Thimm,UAI,2009], see [PhD thesis, Thimm].
|
| NumberSet<S extends java.lang.Number> |
This empty interface is only for the Interval- and IntervalSet-classes
|
| NumberTerm |
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.
|
| NumericalArgumentRanking |
This class provides a acceptability interpretation of arguments by assigning
them real values where larger values indicate more acceptability.
|
| NumericalArgumentRanking.SortingType |
Possible sorting types for the numerical values.
|
| Observation |
An observation is some data point which can be classified.
|
| OctaveSqpSolver |
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.
|
| OctaveSqpSolverEx |
This class implements an example for the OctaveSqpSolver
Version used is 5.2.0
|
| OjAlgoMathUtils |
Provides some utility functions for solving quadratic problems with ojAlgo.
|
| OjAlgoPclUtils |
Provides some utility functions for solving Pcl specific reasoning problems with ojAlgo.
|
| OmegaReductTransformer |
|
| OpenWboSolver |
Provides an interface to the open-wbo MaxSAT solver,
see https://github.com/sat-group/open-wbo.
|
| Operation |
This enumeration lists the possible Operations used by
dynamic preference aggregation updates
|
| OptimisticPASemantics |
P is optimistic wrt.
|
| OptimizationProblem |
This class models a general optimization problem.
|
| OptimizationRootFinder |
This class is the common ancestor for root finders that work with optimizers.
|
| Order<T> |
This class represents an order among some objects.
|
| Ordering<T> |
|
| OrderingExample |
example on how to use the OrderingSemanticsReasoner
|
| OrderingSemantics |
This enum lists ordering semantics.
|
| OrderingSemanticsReasoner |
Reasoner for ordering semantics
|
| OutputField |
This class models single fields used for the PluginOutput
Each field contains its description and its value, e.g.:
Query:
a + b || !a + !b
where "Query:" is the description and "a + b || !a + !b" is the value.
|
| OutputReasoner |
This class models an abstract reasoner for structured argumentation frameworks.
|
| OvercautiousArgumentationAgent |
This class models an overcautious argumentation agent, i.e.
|
| PAInconsistencyMeasure |
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.
|
| PAInconsistencyMeasureExample |
Example code for the PAInconsistencyMeasure.
|
| Pair<E,F> |
This class implements a simple pair of elements.
|
| ParameterisedArgumentativeSelectiveRevisionOperator |
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].
|
| ParameterisedArgumentativeSelectiveRevisionOperator.TransformationType |
|
| ParameterSet |
A set of parameters that can be given to a trainer to
specifiy the training task.
|
| ParameterTrainer<S extends Observation,T extends Category> |
Performs a parameter training on a given trainer, i.e.
|
| PARevisionOperator |
This operator implements a revision of some probabilistic assessment of
arguments upon the observation of an argumentation theory.
|
| ParseException |
This exception is thrown when parse errors are encountered.
|
| ParseException |
This exception is thrown when parse errors are encountered.
|
| ParseException |
This exception is thrown when parse errors are encountered.
|
| ParseException |
This exception is thrown when parse errors are encountered.
|
| ParseException |
|
| Parser<T extends BeliefBase,S extends Formula> |
This class models an abstract parser for belief bases and formulas.
|
| ParserException |
This class models a general exception for parsing.
|
| PartialProbabilityAssignment |
A partial probability assignment for abstract argumentation theories.
|
| PASemantics |
This interface contains common methods for probabilistic argumentation semantics.
|
| PAUpdateOperator |
This operator implements an update of some probabilistic assessment of
arguments upon the observation of an argumentation theory.
|
| PclBeliefSet |
This class models a belief set on probabilistic conditional logic, i.e.
|
| PclBeliefSetQuadraticErrorMinimizationMachineShop |
This class is capable of restoring consistency of a possible inconsistent probabilistic
conditional belief set.
|
| PclDefaultConsistencyTester |
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.
|
| PclParser |
This class implements a parser for probabilistic conditional logic.
|
| PenalizingCreepingMachineShop |
This class is capable of restoring consistency of a possible inconsistent probabilistic
conditional belief set.
|
| Perceivable |
A perceivable object is some event occuring in an environment and perceivable
by an agent.
|
| PerceivableStructuredArgumentationFramework |
This class packs a structured argumentation framework into a
perceivable object.
|
| PingService |
Provides a simple ping service that always returns the request
sent to it.
|
| Pipeline |
Handles all the different building blocks of the SAT centered model
computation.
|
| Pipeline.Builder |
It is safe to use the builder after the build call if the used processors
are stateless.
|
| PlBeliefSet |
This class represents a knowledge base of propositional formulae.
|
| PlCollectors |
A helper class providing some comfort functions dealing with stream
collecting of PlFormula.
|
| PlExample |
Some general examples for using basic propositional logic classes like PlParser and SimplePlReasoner.
|
| PlException |
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.
|
| PlFormula |
This class represents the common ancestor for propositional formulae.
|
| PlFormulaGenerator |
|
| PlMusEnumerator |
This abstract class models a MUS enumerator for propositional logic, i.e.
|
| PlParser |
This class implements a parser for propositional logic.
|
| PlParserFactory |
Manages and creates different parsers for propositional logic.
|
| PlParserFactory.Format |
An enumeration of all available knowledge base formats.
|
| PlParserTest |
JUnit Test class for PlParser.
|
| PlPlugin |
This class provides the JSPF-Plugin for the propositional logic library
Currently plugin is loadable but not executed
|
| PlPredicate |
A specialized predicate for propositional logic that only allows an identifier
but has no arguments and therefore has an arity of zero.
|
| PlSignature |
This class captures the signature of a specific propositional language.
|
| PluginOutput |
This class provides the output for each plugin to be used in the CLI.
|
| PluralityScoringPreferenceAggregator<T> |
Creates an aggregator with plurality scoring
|
| PlWindowInconsistencyMeasurementProcess |
A window inconsistency measurement process for propositional logic
(this class needs to be there as no generics are allowed when instantiating
a DefaultStreamBasedInconsistencyMeasure.
|
| PlWriter |
This class implements a writer for propositional formulas and belief bases.
|
| PmInconsistencyMeasure |
This class implements the inconsistency measure I_{P_m} proposed in
[Jabbour, Raddaoui.
|
| PmInconsistencyMeasure |
This class implements the inconsistency measure $I_\pm$ from [Ulbricht,
Thimm, Brewka.
|
| PmMeasureExample |
|
| PNorm |
The p-norm.
|
| POChanger<T> |
This class is meant to provide a structure to change preference orders and compare the results between changes
|
| PodlaszewskiCaminadaDungTheoryGenerator |
This generator generates abstract argumentation frameworks following the schema
described in "Strong Admissibility Revisited" (COMMA2014) by Martin Caminda, following
and idea by Mikolay Podlaszewski.
|
| Pool |
|
| POParser |
|
| POParserConstants |
Token literal values and constants.
|
| POParserTokenManager |
|
| Possibility |
This class models the possibility modality.
|
| PossibleWorld |
This class represents a possible world of propositional logic, i.e.
|
| PossibleWorldDistance |
This class refines interpretation distances to distance on possible worlds.
|
| PossibleWorldIterator |
Iterates effectively over all interpretation sets worlds of a given signature.
|
| Postulate<S extends Formula> |
Models a general (rationality) postulate, i.e.
|
| PostulateEvaluatable<S extends Formula> |
Classes implementing this interface can be evaluated
wrt.
|
| PostulateEvaluationReport<S extends Formula> |
Summarises the results of a postulate evaluation.
|
| PostulateEvaluator<T extends Formula,U extends BeliefSet<T,?>> |
Evaluates some approach (reasoner, measure, etc.) wrt.
|
| Power |
This class represents a term raised to some power.
|
| POWriter<T> |
|
| Predicate |
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.
|
| PreferenceAggregator<T> |
This interface is meant to be used for the aggregation of some generic preference orders
|
| PreferenceHandling |
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.
|
| PreferenceOrder<T> |
This class extends the BinaryRelation-class with a check for totality and
transitivity
|
| PreferencesIntegerBugExample |
|
| PreferencesPlugin |
The CLI-Plugin for the Preferences-Package
|
| PreferredCountInconsistencyMeasure<T extends DungTheory> |
|
| PreferredReasoner<T extends Formula> |
This reasoner for ABA theories performs inference on the preferred extensions.
|
| PreferredReasoner |
|
| PreferredReasoner |
a set of arguments S is preferred iff it is maximal wrt.
|
| PreferredReasoner |
a set of arguments S is preferred iff it is maximal wrt set inclusion admissible.
|
| PriestWorld |
A three-valued interpretation for propositional logic from
Priest's three valued logic (3VL) [Priest, G.: Logic of paradox.
|
| PriestWorld.TruthValue |
The three truth values.
|
| PrInconsistencyMeasure<S extends Formula> |
This class models the P inconsistency measure from e.g.
|
| ProbabilisticAggregatingNorm |
This distance function uses an aggregator on a probabilistically normalized distance
for probabilities of each value.
|
| ProbabilisticArgumentationFramework |
This class implements the probabilistic argumentation framework approach
of [Li, Oren, Norman.
|
| ProbabilisticConditional |
This class represents a probabilistic conditional of the form (B|A)[p]
with formulas A,B and a probability p.
|
| ProbabilisticExtension |
This class implements a probabilistic interpretation for Dung argumentation frameworks, cf.
|
| ProbabilisticLotteryAgent |
An agent in a game of argumentation lotteries.
|
| ProbabilisticLotteryAgentGenerator |
Generates lottery agents.
|
| ProbabilisticPNorm |
This class implement the p-norm distance function where distances are normalized
corresponding to their distance to 0.5.
|
| ProbabilisticRankingReasoner |
Implements a graded semantics reasoner based on the ideas from [Thimm, Cerutti, Rienstra; 2018].
|
| ProbabilisticRankingReasonerExample |
Example code for using graded semantics reasoner based on the ideas from [Thimm, Cerutti, Rienstra; 2018].
|
| ProbabilisticSum |
Represents the probabilistic sum in fuzzy logic, i.e., S(x,y)=x+y-xy
|
| Probability |
This class represents a probability, i.e.
|
| ProbabilityAware |
|
| ProbabilityDistribution<T extends Interpretation<PlBeliefSet,PlFormula>> |
This class represents a probability distribution on some logical language
|
| ProbabilityFunction<T extends java.lang.Comparable<T>> |
This class represents a probability distribution over some set of objects
|
| ProblemInconsistentException |
This exception is thrown when a problem cannot be solved due to its inconsistency.
|
| ProblemInconsistentException |
This exception is thrown when a problem cannot be solved due to its inconsistency.
|
| ProboProblem |
This enum contains all supported problems for probo-based reasoner.
|
| ProboProblem.SubProblem |
The actual computational sub-problem.
|
| ProboReasoner |
This reasoner makes use of an external executable for solving reasoning problems
in abstract argumentation.
|
| ProboTest |
|
| Processor<I,O> |
|
| Product |
This class models a product of two terms.
|
| ProductAggregator |
This aggregation function models the product function.
|
| ProductNorm |
Represents the product-norm in fuzzy logic, i.e., T(x,y)=xy
|
| Program |
This class models an ASP-Core-2 program, meaning a set of rules and
optionally a query.
|
| PropagationRankingReasoner |
This class implements the argument ranking approach of [Delobelle.
|
| PropagationRankingReasoner.PropagationSemantics |
The three propagation semantics:
PROPAGATION1 ("Propa_epsilon")
PROPAGATION2 ("Propa_{1+epsilon}")
PROPAGATION3 ("Propa_{1->epsilon}")
|
| Proposition |
This class represents a simple proposition in propositional logic.
|
| PropositionalMapping |
Contains the propositional representation of the arguments and links of some
ADF.
|
| PropositionalTransformer |
|
| Protocol |
A protocol gives instructions in which order agents have to be asked
for actions in a multi-agent system.
|
| ProtocolGenerator<T extends Protocol,S extends Agent,R extends MultiAgentSystem<S>> |
Generates protocols for simulation.
|
| ProtocolListener |
A protocol listener listens on a protocol and is notified whenever an action is executed.
|
| ProtocolTerminatedException |
A ProtocolTerminatedException is thrown when
a protocol is asked to perform a step but has already terminated.
|
| Prover9FolReasoner |
|
| Prover9Test |
JUnitTest to test Prover9
|
| Prover9Writer |
|
| QbfExample |
Some general examples for quantified boolean formulas and for parsers and
writers.
|
| QbfParser |
This class implements a parser for quantified boolean formulas.
|
| QbfReasonersExample |
Examples for various QBF solvers.
|
| QbfSolver |
Abstract QBF sat solver to be implemented by concrete solvers.
|
| QbfTest |
Test class for basic qbf functionalities.
|
| QbPossibleWorld |
This class represents a possible world of quantified boolean logic, i.e.
|
| QCirParser |
This class implements a parser for the QCIR (Quantified CIRcuit) format.
|
| QCIRTest |
Test class for parsing QCIR files.
|
| QdimacsParser |
This class implements a parser for the QDIMACS input format.
|
| QdimacsParser.Answer |
Possible answers that solvers can find for a given QDIMACS problem.
|
| QDIMACSTest |
Test class for parsing QDIMACS files.
|
| QdimacsWriter |
Converts belief bases to QDIMACS format and prints them.
|
| Quadruple<E,F,G,H> |
This class implements a simple quadruple of elements.
|
| QuadrupleSetSignature<T,S,U,R> |
This class models a signature as four sets of formulas.
|
| QualifiedExample |
|
| QualifiedReasoner |
Reasoner for qualified sigma-semantics.
|
| QualitativeReasoner<B extends BeliefBase,F extends Formula> |
The general interface for objects that are able to query a belief base
with some formula and return either TRUE or FALSE as answer.
|
| QuantifiedFormula |
Interface for a QuantifiedFormula with a set of quantified variables
implementing an all- or exist-quantor for example.
|
| QuantifiedFormulaSupport<T extends RelationalFormula> |
This class provides common functionalities for quantified formulas, i.e.
|
| QuantitativeReasoner<B extends BeliefBase,F extends Formula> |
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.
|
| QueryProposition |
Action queries are represented as propositional formulas with three possible
types of propositions: holds, always and necessarily propositions.
|
| QuteSolver |
|
| RaAbstraction |
The "abstraction" postulate for ranking semantics as proposed in
[Amgoud, Ben-Naim.
|
| RaAdditionOfAttackBranch |
The "addition of attack branch" postulate for ranking semantics as formalized
in [Bonzon, Delobelle, Konieczny, Maudet.
|
| RaAdditionOfDefenseBranch |
The "addition of defense branch" postulate for ranking semantics as
formalized in [Bonzon, Delobelle, Konieczny, Maudet.
|
| RaAttackVsFullDefense |
The "attack vs full defense" postulate for ranking semantics as proposed in
[Bonzon, Delobelle, Konieczny, Maudet.
|
| RaCardinalityPrecedence |
The "cardinality precedence" postulate for ranking semantics as proposed in
[Amgoud, Ben-Naim.
|
| RaCounterTransitivity |
The "counter-transitivity" postulate for ranking semantics as proposed in
[Amgoud, Ben-Naim.
|
| RaDefensePrecedence |
The "defense precedence" postulate for ranking semantics as proposed in
[Amgoud, Ben-Naim.
|
| RaDistDefensePrecedence |
The "distributed-defense precedence" postulate for ranking semantics as
proposed in [Amgoud, Ben-Naim.
|
| RaIncreaseOfAttackBranch |
The "increase of attack branch" postulate for ranking semantics as formalized
in [Bonzon, Delobelle, Konieczny, Maudet.
|
| RaIncreaseOfDefenseBranch |
The "increase of defense branch" postulate for ranking semantics as
formalized in [Bonzon, Delobelle, Konieczny, Maudet.
|
| RaIndependence |
The "independence" postulate for ranking semantics as proposed in [Amgoud,
Ben-Naim.
|
| RandomAspicArgumentationTheoryGenerator |
Generates random ASPIC argumentation theories.
|
| RandomAspicReasoner<T extends Invertable> |
This class implements an approximate reasoner for ASPIC+ that randomly
samples arguments.
|
| RandomIncisionFunction<T extends Formula> |
This class implements an incision function that just randomly
selects a minimal incision.
|
| RandomKernelContractionOperator |
This class implements a simple kernel base contraction for propositional logic with
an incision function that randomly selects its incisions.
|
| RandomLotteryAgent |
A baseline agent for argumentation games who always
returns some random move.
|
| RandomLotteryAgentGenerator |
Generates baseline lottery agents.
|
| RandomSampler |
|
| RandomSatSampler |
A sampler for uniform random k-SAT instances.
|
| RandomSubsetIterator<T> |
Iterates over all subsets of a given sets in a random order.
|
| RankingFunction |
A ranking function (or ordinal conditional function, OCF) that maps possible worlds
of a propositional language to integers.
|
| RankingFunction<T> |
This class is meant to provide ranking functions to given preference orders
and vice versa.
|
| RankingPostulate |
An abstract postulate for ranking-based semantics in abstract argumentation;
the ancestor of all concrete postulates.
|
| RankingReasonerTest |
Test class for checking counterexamples for some postulates.
|
| RankingSemanticsExample |
Example code for ranking semantics.
|
| RankingSemanticsExample2 |
Example code for even more ranking semantics.
|
| RankingsTest |
Test class for basic ranking functionalities.
|
| RankingTools |
Common utility methods for ranking reasoners.
|
| RaNonAttackedEquivalence |
The "non-attacked equivalence" postulate for ranking semantics as proposed in
[Bonzon, Delobelle, Konieczny, Maudet.
|
| RaPostulateExample |
Example code for postulates for ranking semantics.
|
| RaQualityPrecedence |
The "quality precedence" postulate for ranking semantics as proposed in
[Amgoud, Ben-Naim.
|
| RaSelfContradiction |
The "self-contradiction" postulate for ranking semantics as proposed
in [Matt, Toni.
|
| RaStrictAdditionOfDefenseBranch |
The "strict addition of defense branch" postulate for ranking semantics as
formalized in [Bonzon, Delobelle, Konieczny, Maudet.
|
| RaStrictCounterTransitivity |
The "strict counter-transitivity" postulate for ranking semantics as proposed
by [Amgoud, Ben-Naim.
|
| RationalPASemantics |
P is rational wrt.
|
| RaTotal |
The "total" postulate for ranking semantics as proposed in [Bonzon,
Delobelle, Konieczny, Maudet.
|
| RaVoidPrecedence |
The "void precedence" postulate for ranking semantics as proposed by [Amgoud,
Ben-Naim.
|
| RclBeliefSet |
This class models a belief set on relational conditional logic, i.e.
|
| RclExample |
Example code illustrating the use of working with relational
conditionals and using c reasoning.
|
| RclParser |
This class implements a parser for relational conditional logic.
|
| RdlExample |
RDL Test
|
| RDLJUnitTest |
|
| RdlParser |
This class implements a parser for default logic.
|
| RealVectorNorm |
A norm for real vector spaces.
|
| Reasoner<O,B extends BeliefBase,F extends Formula> |
The general interface for objects that are able to query a belief base
with some formula.
|
| ReasonerExample |
|
| Rebut |
This notion of attack models the rebut relation.
|
| Rebuttal |
This attack notion models the rebuttal relation; A is defeated by B iff claim(B) == \neg claim(A).
|
| RecognitionFunction |
This class realizes a recognition function as explained in
[Rienstra, Thimm, in preparation].
|
| ReferenceWorld |
Instances of this class represent reference worlds, i.e.
|
| RefineLargerSatEncoding |
Prevents smaller interpretations from being computed, but also allows different interpretations of at least the same size.
|
| RefineUnequalSatEncoding |
|
| Relation |
This enumeration lists the possible relations between two elements
in preference orders
|
| RelationalConditional |
Instances of this class represent relational conditionals.
|
| RelationalFormula |
This is the abstract base class for relational formulas,
i.e.
|
| RelationalProbabilisticConditional |
This class represents a relational probabilistic conditional, i.e.
|
| RelationalRankingFunction |
A relational ranking function (or relational ordinal conditional function, ROCF) that maps
Herbrand interpretations to integers.
|
| RelativeBipolarSatEncoding |
|
| RelativeKBipolarSatEncoding |
|
| RelativeKBipolarStateProcessor |
Decides if an ADF becomes k-bipolar relative to some truth assignments.
|
| RemainderSets<T extends Formula> |
This class represents the set of remainder sets constructed
from a belief base.
|
| RepairExample |
|
| RevisionCompareModel |
The data-model used to compare two different revision approaches.
|
| RevisionComparePresenter |
This class couples the RevisionCompare View and Model, it needs to know the implementation used to
load external belief base files, see FileHandler interface.
|
| RevisionComparePresenter.FileHandler |
This interface is used by the RevisionComparePresenter to handle the file loading.
|
| RevisionCompareView |
The default view for a revision compare.
|
| RevisionTest |
Uses the RevisionCompareView in a JFrame to compare the different revision methods in ASP.
|
| RigidProtocol |
This class models a rigid protocol, i.e.
|
| RiveretTheoryLearner |
Implementation of the algorithm for learning (grounded) labelings from:
Riveret, Régis, and Guido Governatori.
|
| RoleAssertion |
This class models a role assertion in description logic, i.e.
|
| Root |
This class represents a the nth root function
|
| RootFinder |
Classes which extend this class represent algorithms for
finding zero points (roots) of functions.
|
| RoundRobinProtocol |
This class models a round robin protocol for multi-agent systems.
|
| RpclBeliefSet |
This class models a belief set on relational probabilistic conditional logic, i.e.
|
| RpclCondensedProbabilityDistributionParser |
|
| RpclCondensedProbabilityDistributionParserConstants |
|
| RpclCondensedProbabilityDistributionParserTokenManager |
|
| RpclMeReasoner |
General ME-reasoner for RPCL.
|
| RpclMeReasonerExample |
|
| RpclMeReasonerExample2 |
|
| RpclParser |
This class implements a parser for relational probabilistic conditional logic.
|
| RPCLPlugin |
relational probabilistic conditional logic plugin for the tweety cli
skeleton
|
| RpclProbabilityDistribution<T extends Interpretation<FolBeliefSet,FolFormula>> |
Objects of this class represent probability distributions on the interpretations
of an underlying first-order signature for a relational probabilistic conditional knowledge base.
|
| RpclProbabilityDistributionParser |
|
| RpclProbabilityDistributionParserConstants |
Token literal values and constants.
|
| RpclProbabilityDistributionParserTokenManager |
Token Manager.
|
| RpclSemantics |
This interface describes semantics for relational probabilistic logic.
|
| Rule<C extends Formula,P extends Formula> |
This interface models a general rule, i.e.
|
| RuleAdapter |
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.
|
| RuleBasedCReasoner |
This is a reasoner using c-representation and rules to solve these c-representations.
|
| RuleBasedCReasoner.Rule |
A rule that is applicable by the RuleBasedCReasoner to reason a
c-representation given a conditional belief base. |
| RuleComparator<T extends Invertable> |
|
| RuleFormulaGenerator<T extends Invertable> |
|
| RuleSet<T extends Rule<?,?>> |
This class represents a set of rules and provides several
auxiliary methods for accessing such a set.
|
| SActionQuery |
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.
|
| SActionQuerySatisfactionTester |
This class provides methods capable of checking if a given transition system
satisfies a set of action queries in the action query language s.
|
| SActionQuerySet |
This class models a set of action queries in the language S which is based on
the query language "P" discussed in the paper: Action Languages.
|
| SafetyReasoner |
a set of arguments S is safe wrt.
|
| SafExample |
Example code for using social abstract argumentation.
|
| SAFRankingReasoner |
This class implements the ranking-based "SAF" semantics approach as proposed
by [Bonzon, Delobelle, Konieczny, Maudet.
|
| SasAgent |
This class represents an agent in a structured argumentation system.
|
| Sat4jSolver |
Uses the Sat4j library for SAT solving (note that currently only the light version is used).
|
| SatCompleteReasoner |
Uses a SAT solver to determine complete extensions.
|
| SatEncoding |
|
| SatLinkStrategy |
Computes the LinkType via two Sat-calls.
|
| SatReasoner |
Uses the default SAT reasoner to perform reasoning in propositional logic
|
| SatSolver |
Abstract class for specifying SAT solvers.
|
| SatSolverState |
A high level representation of a sat solver state.
|
| SatStableReasoner |
Uses a SAT solver to determine stable extensions.
|
| SccCF2Reasoner |
Reasoner for CF2 extensions using scc-recursiveness.
|
| ScepticalLiteralTransformationFunction |
This class represents the sceptical transformation function
for literals as introduced in [1].
|
| ScepticalLiteralTransformationFunctionTest |
|
| SCF2Reasoner |
Reasoner for SCF2 extensions using scc-recursiveness.
|
| SCOOCNaiveReasoner |
reasoner for SCOOC-naive semantics.
|
| ScoringPreferenceAggregator<T> |
This class extends the interface for preference aggregation with scoring
Scorings are implemented separately.
|
| ScoringPreferenceAggregatorTest |
|
| ScreenedMaxichoiceConsolidation |
This class implements the screened maxi-choice consolidation operator from [1].
|
| ScreenedRemainderSets |
This class represents the set of Screened Consistent Remainder Sets as
defined in [1].
|
| SdInconsistencyMeasure |
This class implements the inconsistency measure $I_sd$ from
[Ulbricht, Thimm, Brewka.
|
| SeeAcceptabilityReasoner |
Implements the SEE approach ("selective extension enumeration") to
determine the set of credulously acceptable arguments of an AF
wrt.
|
| SeemAcceptabilityReasoner |
Implements the SEEM approach ("selective extension enumeration with MaxSAT") to
determine the set of credulously acceptable arguments of an AF
wrt.
|
| SelectionCommandParameter |
This class expands the CommandParameter with a selection-array containing
strings the parameter supports
|
| SelectionFunction<T extends Formula> |
This interface models a general selection function for remainder sets
|
| SelectiveRevisionOperator<T extends Formula> |
This class implements a selective revision operator following [Ferme:1999].
|
| SelfSupportingReasoner |
a set of arguments S is self-supporting iff all arguments in S are e-supported by S.
|
| Semantics |
This enum lists all semantics.
|
| SemiFoundedPASemantics |
P is semi-founded wrt.
|
| SemiOptimisticPASemantics |
P is semi-optimistic wrt.
|
| SemiQualifiedReasoner |
Reasoner for semi-qualified sigma-semantics.
|
| SequenceFlow |
|
| SetAttack |
This class models an attack between a set of arguments and an argument.
|
| SetComparator<T> |
|
| SetInterpretation |
|
| SetSupport |
This class models a support between a set of arguments and an argument.
|
| SetTools<E> |
This class provides some methods for set operations.
|
| ShapleyCulpabilityMeasure<S extends Formula,T extends BeliefSet<S,?>> |
This class implements the Shapley culpability measure.
|
| Shell |
|
| Signature |
A signatures lists the atomic language structures for some language.
|
| SignedCulpabilityMeasure |
Classes implementing this interface represent signed culpability measures, i.e.
|
| SimpleAccumulator |
This implementation of an accumulator simply sums
up the categorizations of the argument trees.
|
| SimpleAdmissibleReasoner |
This reasoner for Dung theories performs inference on the admissible extensions.
|
| SimpleAspicOrder<T extends Invertable> |
|
| SimpleAspicOrder<T extends Invertable> |
|
| SimpleAspicReasoner<T extends Invertable> |
|
| SimpleCharStream |
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
|
| SimpleCharStream |
|
| SimpleCharStream |
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
|
| SimpleCharStream |
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
|
| SimpleCharStream |
|
| SimpleCompleteReasoner |
This reasoner for Dung theories performs inference on the complete extensions.
|
| SimpleConflictFreeReasoner |
This reasoner for Dung theories performs inference on the conflict-free extensions.
|
| SimpleCReasoner |
This class models a brute force c-reasoner for conditional logic.
|
| SimpleDeductiveReasoner |
This class implements a brute force approach to deductive argumentation.
|
| SimpleDefaultReasoner |
Implements a naive reasoner for default logic based on exhaustive
application of defaults in process trees.
|
| SimpleDpllSolver |
|
| SimpleDpllSolverTest |
|
| SimpleFolReasoner |
Uses a naive brute force search procedure for theorem proving.
|
| SimpleFunction<T,S> |
Encapsulates common methods of mathematical functions with a single parameter.
|
| SimpleGeneticOptimizationSolver |
This class implements a simple genetic optimization algorithm for solving
optimization problems with box or equality constraints on float variables.
|
| SimpleGeneticOptimizationSolverEx |
This class implements an example for the Genetic Optimization Solver
It is natively implemented
|
| SimpleGeneticOptimizationSolverTest |
|
| SimpleGroundedReasoner |
This reasoner for Dung theories performs inference on the grounded extension.
|
| SimpleIdealReasoner |
This reasoner for Dung theories performs inference on the ideal extension.
|
| SimpleIncrementalSatSolver |
|
| SimpleLink |
A simple immutable representation of ADF links.
|
| SimpleLogicalFormula |
A formula of a logical language
|
| SimpleMlnReasoner |
|
| SimpleMlReasoner |
This class implements inference for modal logic using a brute-force approach.
|
| SimpleNode |
A simple node of a graph with a name.
|
| SimpleNode |
|
| SimplePafReasoner |
This class implements a naive algorithm for computing
probabilities of extensions in probabilistic argumentation frameworks
from [Li, Oren, Norman.
|
| SimplePlInterpolantEnumerator |
Implements an exhaustive search approach to compute all interpolants of
a knowledge base wrt.
|
| SimplePlInterpolantEnumeratorExample |
Illustrates the use of the SimplePlInterpolantEnumerator
|
| SimplePlLogicArgument |
|
| SimplePlLogicDeductiveKnowledgebase |
|
| SimplePlLogicExample |
For testing purpose only
|
| SimplePlLogicParser |
|
| SimplePlReasoner |
Naive classical inference (checks all interpretations for satisfiability).
|
| SimplePlRule |
Basic data structure for handling simple rule
|
| SimplePreferredReasoner |
This reasoner for Dung theories performs inference on the preferred extensions.
|
| SimpleProductSemantics |
The simple product semantics from [Leite, Martins; IJCAI 2011, Def.
|
| SimpleRealValuedFunction |
A real-valued function.
|
| SimpleRelationalCReasoner |
This class models a relational brute force c-reasoner for relational conditional logic.
|
| SimpleRevisionCompareModel |
The data-model used to compare two different revision approaches.
|
| SimpleRevisionComparePresenter |
This class couples the SimpleRevisionCompare View and Model, it needs to know the implementation used to
load external belief base files, see FileHandler interface.
|
| SimpleRevisionComparePresenter.FileHandler |
This interface is used by the SimpleRevisionComparePresenter to handle the file loading.
|
| SimpleRevisionCompareView |
The default view for a revision compare.
|
| SimpleSafSampler |
This class implements a belief base sampler for structured argumentation
frameworks.
|
| SimpleSamplingMlnReasoner |
This MLN reasoner employs simple random sampling from
the set of interpretations to compute the probability of a formula.
|
| SimpleSatSolverState |
A dummy state that can be used in combination with non-incremental
Sat-Solvers and SimpleIncrementalSatSolver at positions where a
SatSolverState is required. |
| SimpleSccCompleteReasoner |
This reasoner for Dung theories performs inference on the complete extensions.
|
| SimpleSemiStableReasoner |
This reasoner for Dung theories performs inference on the semi-stable extensions.
|
| SimpleStableReasoner |
This reasoner for Dung theories performs inference on the stable extensions.
|
| SimpleStageReasoner |
This reasoner for Dung theories performs inference on the stage extensions.
|
| SimulatedAnnealing |
This class implements the simulated annealing algorithm for combinatrics problems
It is natively implemented
|
| SimulatedAnnealingEx |
|
| SimulatedAnnealingOnConstrProb |
implements the Simulated Annealing algorithm
for optimization problems
|
| SimulatedAnnealingOnConstrProbEx2 |
This class implements an example for Simulated Annealing on optimization problems
It is natively implemented
|
| SimulationParameters |
Objects of this class store additional simulation parameters that
should be shared among the generating components of a simulation.
|
| SimulationResult<S extends AbstractProtocol & GameProtocol,T extends Agent,R extends MultiAgentSystem<T>> |
Instances of this class summarize information
on a performed simulation.
|
| SinglePeakWeightVector |
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)
|
| SingleSetSignature<T> |
This class models a signature as a set of formulas.
|
| SingleValeWeightVector |
|
| SingleValuedInterpretation |
|
| SmoothedPenalizingCreepingMachineShop |
This class is capable of restoring consistency of a possible inconsistent probabilistic
conditional belief set.
|
| SmoothingFunction |
A function that smoothes two values with a smooting factor, i.e.
|
| SocialAbstractArgumentationFramework |
This class implements a social abstract argumentation framework from
[Joao Leite, Joao Martins.
|
| SocialMapping<L> |
Implements a mapping from arguments to social value.
|
| Solver |
This abstract class models an abstract solver for constraint satisfaction or optimization problems.
|
| SolverException |
This class models a generic exception for ASP solvers.
|
| Sort |
A sort of first-order logic.
|
| SpassFolReasoner |
|
| SPASSMlReasoner |
|
| SPASSTest |
JUnitTest to test SPASS (test cases from TPTPTest) |
| SPASSTest |
JUnit Test class for SPASS Prover for modal formulas.
|
| SPASSWriter |
This class prints single first-order logic formulas and knowledge bases to
the SPASS format.
|
| SPASSWriter |
This class prints single first-order modal logic formulas and knowledge bases to
the SPASS format.
|
| SpecialFormula |
This class captures the common functionalities of the special
formulas tautology and contradiction.
|
| SpecialFormula |
This class captures the common functionalities of the special
formulas tautology and contradiction.
|
| StableReasoner<T extends Formula> |
This reasoner for ABA theories performs inference on the stable extensions.
|
| StableReasoner |
|
| StableReasoner |
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.
|
| StableReasoner |
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.
|
| Stage2Reasoner |
Reasoner for Stage2 semantics using scc-recursiveness
definition see:
Dvorak, Gaggl: Incorporating Stage Semantics in the SCC-recursive Schema for Argumentation Semantics 2012
|
| StandardFolWriter |
Writes FOL formulas and knowledge bases in the standard TweetyProject
format, see parser.FolParser.
|
| StandardFolWriterExample |
Shows how to use the StandardFolWriter
|
| StartEvent |
|
| State |
Represents a state in an action transition system, which is a representation
of an interpretation of all fluent names in an action description.
|
| Statement |
This class models a mathematical statement, i.e.
|
| StateProcessor |
|
| StaticLaw |
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
|
| StratifiedLabeling |
This class implements stratified labelings as in [Thimm, Kern-Isberner, 2013].
|
| StratifiedLabelingExample |
Example code for using stratified labelings by Thimm/Kern-Isberner
|
| StratifiedLabelingReasoner |
This class implements a stratified labeling reasoner.
|
| StreamBasedInconsistencyMeasure<S extends Formula> |
General interface for inconsistency measures working on streams.
|
| StreamInconsistencyEvaluationExample |
|
| StreamInconsistencyEvaluationExample2 |
|
| StrictInferenceRule<T extends Invertable> |
|
| StrictNegation |
This class models the strict negation of an
atom (as apposed to a NAF negation:
DefaultNegation). |
| StrictRule |
This class models a strict rule in defeasible logic programming.
|
| StringListCommandParameter |
This class models a string list command parameter for
Work-in-Progress, do not use!
|
| StringTerm |
This class represents terms which are objects identified by a
string.
|
| StrongAttack |
This notion of attack models the strong attack relation.
|
| StrongConfidentAttack |
This notion of attack models the strong confident attack relation.
|
| StrongUndercut |
This notion of attack models the strong undercut relation.
|
| StructuredArgumentationFramework |
This class represents a structured argumentation framework, i.e.
|
| StructuredArgumentationSystem |
This class represents a structured argumentation system, i.e.
|
| SubgraphProbabilityFunction |
Represents a probability function on the subgraphs of some Dung theory.
|
| SubgraphProbExample |
Example code for showing how to work with subgraph probability distributions and updates.
|
| Subprocess |
|
| SubsetIterator<T> |
Iterates over all subsets of a given set.
|
| SubsetIteratorExample |
|
| Sum |
This class models a sum of two terms.
|
| SumAggregator |
This aggregation function models the sum function.
|
| Support |
This interface captures common methods of different interpretations of the support relation in
bipolar abstract argumentation theories.
|
| SupportVectorMachine |
Realizes a support vector machine classifier utilizing LIBSVM.
|
| SvmExample |
|
| SVMTest |
|
| SynchronousProtocol |
This class models a synchronous protocol for multi-agent systems.
|
| SyntacticEnumeratingIterator |
Generates all syntactic variations of knowledge bases
|
| SyntacticEnumeratingPlBeliefSetSamplerExample |
|
| SyntacticRandomPlBeliefSetSamplerExample |
|
| SyntacticRandomSampler |
This sampler implements a random generation algorithm for generating formulas, based on
the syntax tree of propositional formulas.
|
| T1BeliefState |
This belief state consists of a simple recursive opponent model.
|
| T1Configuration |
This class encapsulates configuration options for generating
T1 belief states.
|
| T2BeliefState |
This belief state consists of a probability distribution over
other opponent models.
|
| T2Configuration |
This class encapsulates configuration options for generating
T2 belief states.
|
| T3BeliefState |
This belief state consists of a probability distribution over
other opponent models with virtual arguments.
|
| T3Configuration |
This class encapsulates configuration options for generating
T3 belief states.
|
| TabuSearch |
implements a simple Tabu Search without long term memory
for combinatorics problems
|
| TabuSearchOnConstrProb |
implements a simple Tabu Search without long term memory
for optimization problems
|
| TabuSearchOnConstrProbEx |
This class implements an example for Tabu search
It is natively implemented
|
| Task |
|
| TaskType |
|
| Tautology |
A tautological formula.
|
| Tautology |
A tautological formula.
|
| TautologyAcceptanceCondition |
|
| TCoNorm |
Represents a T-norm in fuzzy logic, i.e., a generalization of a logical
conjunction on values in [0,1].
|
| Term<T> |
A term of a logical language, that can be given as argument for logical constructs
like atoms or functors.
|
| Term |
This class models a mathematical term.
|
| TermAdapter<T> |
Abstract base class implementing the substitute(), getSort(), getTerms(), and
containsTermsOfType() methods in a way it is useful for terms.
|
| TestArguments |
Testing argument syntax.
|
| TestConditionalStructure |
|
| TestDeLP |
Testing the command line stuff for DeLP.
|
| TestDTree |
Testing dialectical trees.
|
| TestFormulaParsing |
Testing DeLP formula parsing.
|
| TestKBParsing |
Parsing DeLPs.
|
| TestNicePossibleWorld |
|
| TestQueries |
Testing some example KBs with various queries.
|
| TestRules |
Tests for rules: facts, strict and defeasible rules.
|
| TextfileIterator |
Enumerates all belief bases from a text file; the file contains one
belief base per line.
|
| TgfParser |
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.
|
| TgfWriter |
Writes an abstract argumentation framework into a file of
the TGF format.
|
| ThreeValuedBitSet |
Inspired by BitSet but with three values.
|
| TNorm |
Represents a T-norm in fuzzy logic, i.e., a generalization of a logical
conjunction on values in [0,1].
|
| Token |
Describes the input token stream.
|
| Token |
Describes the input token stream.
|
| Token |
Describes the input token stream.
|
| Token |
Describes the input token stream.
|
| Token |
Describes the input token stream.
|
| TokenMgrError |
Token Manager Error.
|
| TokenMgrError |
Token Manager Error.
|
| TokenMgrError |
Token Manager Error.
|
| TokenMgrError |
Token Manager Error.
|
| TokenMgrError |
Token Manager Error.
|
| TopConcept |
This class models the top concept (universal concept) in description logics.
|
| TPTPParser |
This class implements a parser for the TPTP syntax that parses single fol formulas and knowledge bases
(TPTP problem files or axiom files).
|
| TPTPParserExample |
Examples for using TPTPParser.
|
| TPTPTest |
JUnitTest to test TPTP printer and EProver implementation
|
| TPTPWriter |
Prints single first-order logic formulas and full knowledge bases to TPTP format.
|
| Trainer<S extends Observation,T extends Category> |
|
| TrainingParameter |
A single parameter for a training method.
|
| TrainingSet<S extends Observation,T extends Category> |
A set of observations together with their category.
|
| TransformationFunction<T extends Formula> |
This interface represents a transformation function for selective revision [Ferme:1999].
|
| Transformer<R> |
Transforms an acceptance condition into an arbitrary structure.
|
| Transition |
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.
|
| TransitionSystem |
This class represents an action transition system for a fixed action
signature with a set of states and a set of transitions between states.
|
| TranslateTest |
Tests the FOLPropTranslator
|
| TranslationTest |
|
| Translator |
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.
|
| TravelingSalesman |
implements the traveling salesman problem.
|
| TravelingSalesmanEx |
Class implementing an example for a TSP on a cartesian fully connected graph
|
| TravelingSalesmanEx2 |
Class implementing an example for a TSP on a cartesian fully connected graph
|
| Triple<E,F,G> |
This class implements a simple triple of elements.
|
| TripleSetSignature<T,S,U> |
This class models a signature as three sets of formulas.
|
| TruthfulArgumentationAgent |
This class models a truthful argumentation agent, i.e.
|
| TseitinTransformer |
|
| TseitinTransformer.Builder |
|
| TuplesRankingReasoner |
This class implements the "tuples*" argument ranking approach as proposed by
[Cayrol, Lagasquie-Schiex.
|
| TweetyCli |
This class implements a simple command line interface for accessing
the functionalities provided by the Tweety libraries.
|
| TweetyConfiguration |
This interface contains some configuration options for
Tweety.
|
| TweetyConfiguration.LogLevel |
The possible log levels.
|
| TweetyLogging |
This class handles the global logging configuration.
|
| TweetyPlugin |
This class provides the base for each plugin's functionality
|
| TweetyServer |
Uses the Grizzly HTTP server to instantiate the Tweety server
that provides API access to Tweety services.
|
| TwoValuedInterpretationIterator |
|
| TwoValuedModelSatEncoding |
|
| TypedStructure |
This interface defines method which are given by every TypedStructure like a
Predicate or an Functor.
|
| TypedStructureAdapter |
The abstract parent for predicates and functors implementing the
TypedStructure interface.
|
| UnbiasedCreepingMachineShop |
This class is capable of restoring consistency of a possible inconsistent probabilistic
conditional belief set.
|
| Undercut |
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.
|
| Undercut |
This notion of attack models the undercut relation.
|
| UndirectedEdge<T extends Node> |
Instances of this class represent undirected edges.
|
| Union |
This class models an union in description logics.
|
| UnionSetView<E> |
|
| UniversalRestriction |
This class models an universal restriction in description logics,
i.e.
|
| UnstableCountInconsistencyMeasure<T extends DungTheory> |
|
| Update<T> |
This Update-class provides update-elements used within dynamic preference aggregations
|
| UpdateEvent<T> |
The class for event objects used in dynamic preference aggregation
|
| UpdateListener<T> |
The interface for UpdateListener used for dynamic preference aggregation
|
| UpdatePrinter<T> |
This exemplary class implements a simple printer for update events writing its result into the console
|
| UpdateStream<T> |
Konzeption:
Der Update-Stream ist eine Datenstruktur, die benutzt wird, um eine Reihe von Updates fuer dynamische POs
einzuspeisen und zu verwalten.
|
| UPParser |
Update Parser for reading updates for dynamic Preference Aggregation
Please note: update file syntax changed from
(index, operation, amount, element)
e.g.
|
| UPParserConstants |
Token literal values and constants.
|
| UPParserTokenManager |
Token Manager.
|
| UpperApproxDistanceMinimizationInconsistencyMeasure |
This class models an approximation from above to the distance minimization inconsistency measure as proposed in [Thimm,UAI,2009], see [PhD thesis, Thimm].
|
| UtilityBasedAgentGenerator |
Generates baseline lottery agents.
|
| UtilityBasedLotteryAgent |
|
| UtilityFunction<S,T extends java.util.Collection<S>> |
Objects of this class represent utility function that assess
dialogue traces.
|
| UtilityFunction |
This interface models an utility function, i.e.
|
| UtilityFunction |
A utility function that maps divisions to utilities
|
| VarConstNeqRequirement |
This class represents a single grounding requirement stating that a variable
is not allowed to be substituted by a specific constant.
|
| Variable |
A Variable is a placeholder for Constants in a generic formula of
a logic language.
|
| Variable |
This class models a variable as a mathematical term.
|
| VariableTest |
|
| VarsNeqRequirement |
This class represents a single grounding requirement stating that two
variables are not allowed to be substituted by the same constant.
|
| VectorTools |
This class contains some auxiliary methods for
working with vectors.
|
| Verifier |
|
| VerifyAdmissibleSatEncoding |
|
| VetoScoringPreferenceAggregator<T> |
Creates an aggregator for veto scoring
|
| Visitor<U,D> |
A general and easy-to-use interface which allows for type-safe operations on the AcceptanceCondition hierarchy. |
| WeakestLinkOrder<T extends Invertable> |
|
| WeaklyAdmissibleReasoner |
Reasoner for weak admissibility
the reasoner reduces the number of sets we have to check by computing candidate sets instead of checking all sets.
|
| WeightedComponentCountInconsistencyMeasure<T extends DungTheory> |
|
| WeightedCycleCountInconsistencyMeasure<T extends DungTheory> |
|
| WeightedDirectedEdge<S extends Node,T extends java.lang.Number> |
|
| WeightedDungTheory |
Minimalistic Implementation of a weighted argumentation theory
used for learning argumentation theories from labelings
|
| WeightedEdge<S extends Node,T extends java.lang.Number> |
Interface for weighted edges.
|
| WeightedInSumInconsistencyMeasure<T extends DungTheory> |
|
| WeightedOutSumInconsistencyMeasure<T extends DungTheory> |
|
| WeightVector |
This interface is used for
|
| WellFoundedReasoner<T extends Formula> |
This reasoner for ABA theories performs inference on the ideal extension.
|
| WindowInconsistencyMeasurementProcess<S extends Formula> |
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.
|
| Writer |
This class represents an abstract writer for
writing objects into the file system.
|
| ZReasoner |
This class models a z-reasoner for conditional logic.
|