Modifier and Type | Method and Description |
---|---|
private Formula |
CLawParser.parseAlwaysFormula(java.lang.String s,
java.lang.String reqString)
Parses a string containing a single causal law of the form
always A
which is converted to
caused - if !A
|
private Formula |
CLawParser.parseCausedFormula(java.lang.String s,
java.lang.String reqString)
Parses a string containing a single causal law of the form
caused A (if B)? (after C)?
|
private Formula |
CLawParser.parseCausesFormula(java.lang.String s,
java.lang.String reqString)
Parses a string containing a single causal law of the form
A causes B if C
which is converted to
caused B if + after A && C
|
private Formula |
CLawParser.parseDefaultFormula(java.lang.String s,
java.lang.String reqString)
Parses a string containing a single causal law of the form
default A (if B)?
which is converted to the causal law
caused A if A && B
|
Formula |
CParser.parseFormula(java.io.Reader reader) |
Formula |
CLawParser.parseFormula(java.io.Reader reader) |
Formula |
CParser.parseFormula(java.lang.String formula) |
Formula |
CLawParser.parseFormula(java.lang.String s) |
private Formula |
CLawParser.parseInertialFormula(java.lang.String s,
java.lang.String reqString)
Parses a string containing a single causal law of the form
inertial A
which is converted to the causal law
caused A if A after A
|
private Formula |
CLawParser.parseMayCauseFormula(java.lang.String s,
java.lang.String reqString)
Parses a string containing a single causal law of the form
A may cause B if C
which is converted to
caused B if B after A && C
|
private Formula |
CLawParser.parseNonexecutableFormula(java.lang.String s,
java.lang.String reqString)
Parses a string containing a single causal law of the form
nonexecutable A if B
which is converted to
caused - after A && B
|
Modifier and Type | Interface and Description |
---|---|
interface |
CausalLaw
A basic interface representing a causal law.
|
Modifier and Type | Class and Description |
---|---|
class |
CLaw
The action description language C consists of two distinct expressions:
static laws and dynamic laws.
|
class |
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)
|
class |
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
|
Modifier and Type | Interface and Description |
---|---|
interface |
ActionQuery
This is a basic interface for action queries.
|
Modifier and Type | Class and Description |
---|---|
class |
AlwaysQuery
This class represents an always query in the action query language S.
|
class |
HoldsQuery
This class represents a holds query in the action query language S.
|
class |
NecessarilyQuery
This class represents a necessarily query in the action query language S.
|
class |
QueryProposition
Action queries are represented as propositional formulas with three possible
types of propositions: holds, always and necessarily propositions.
|
class |
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.
|
Modifier and Type | Method and Description |
---|---|
boolean |
ActionSignature.isValidFormula(Formula f)
Checks, if a given formula is valid in the sense of an action description,
containing only predicates that are either fluentnames or actionnames and
containing neither quantifiers nor functions.
|
Modifier and Type | Class and Description |
---|---|
class |
ABAParser<T extends Formula> |
Modifier and Type | Method and Description |
---|---|
Formula |
ABAParser.parseFormula(java.io.Reader reader) |
Modifier and Type | Class and Description |
---|---|
class |
CompleteReasoner<T extends Formula> |
class |
FlatABAReasoner<T extends Formula> |
class |
GeneralABAReasoner<T extends Formula> |
class |
IdealReasoner<T extends Formula> |
class |
PreferredReasoner<T extends Formula> |
class |
StableReasoner<T extends Formula> |
class |
WellFoundedReasoner<T extends Formula> |
Modifier and Type | Class and Description |
---|---|
class |
ABAAttack<T extends Formula> |
class |
AbaExtension<T extends Formula>
An set of assumptions.
|
Modifier and Type | Class and Description |
---|---|
class |
ABAAttack<T extends Formula> |
Modifier and Type | Method and Description |
---|---|
static <T extends Formula> |
ABAAttack.allAttacks(ABATheory<T> abat) |
static <T extends Formula> |
ABAAttack.allAttacks(java.util.Collection<Assumption<T>> from,
java.util.Collection<Assumption<T>> to,
ABATheory<T> abat) |
Modifier and Type | Interface and Description |
---|---|
interface |
ABARule<T extends Formula> |
class |
ABATheory<T extends Formula> |
class |
Assumption<T extends Formula> |
class |
Deduction<T extends Formula> |
class |
InferenceRule<T extends Formula> |
class |
Negation<T extends Formula> |
Modifier and Type | Interface and Description |
---|---|
interface |
ABARule<T extends Formula> |
Modifier and Type | Class and Description |
---|---|
class |
Assumption<T extends Formula> |
class |
Deduction<T extends Formula> |
class |
InferenceRule<T extends Formula> |
Modifier and Type | Field and Description |
---|---|
(package private) T |
Assumption.assumption
The assumed formula
|
(package private) T |
Negation.formula
not |
(package private) T |
InferenceRule.head
The rule's conclusion
|
(package private) T |
Negation.negation
not |
Modifier and Type | Method and Description |
---|---|
void |
ABATheory.add(Formula rule) |
Modifier and Type | Method and Description |
---|---|
Formula |
AspicParser.parseFormula(java.io.Reader reader) |
Modifier and Type | Method and Description |
---|---|
protected DungTheory |
RandomAspicReasoner.getDungTheory(AspicArgumentationTheory<T> aat,
Formula query) |
protected DungTheory |
NaiveAspicReasoner.getDungTheory(AspicArgumentationTheory<T> aat,
Formula query) |
protected abstract DungTheory |
AbstractAspicReasoner.getDungTheory(AspicArgumentationTheory<T> aat,
Formula query)
Computes the Dung theory from which the answer will be derived
|
protected DungTheory |
ModuleBasedAspicReasoner.getDungTheory(AspicArgumentationTheory<T> aat,
Formula query) |
Modifier and Type | Class and Description |
---|---|
class |
AspicAttack<T extends Invertable> |
Modifier and Type | Class and Description |
---|---|
class |
AspicArgument<T extends Invertable> |
class |
DefeasibleInferenceRule<T extends Invertable> |
class |
StrictInferenceRule<T extends Invertable> |
Modifier and Type | Method and Description |
---|---|
Formula |
SimplePlLogicParser.parseFormula(java.io.Reader reader) |
Modifier and Type | Class and Description |
---|---|
class |
SimplePlLogicArgument |
class |
SimplePlRule
Basic data structure for handling simple rule
|
Modifier and Type | Method and Description |
---|---|
Formula |
DelpParser.parseFormula(java.io.Reader reader)
A formula here is a Literal, that is an Atom or a negated Atom.
|
Modifier and Type | Class and Description |
---|---|
(package private) class |
ArgumentCompletion
This class models the completion of an argument in the framework of defeasible logic programming.
|
Modifier and Type | Class and Description |
---|---|
class |
DefeasibleRule
This class models a defeasible rule in defeasible logic programming.
|
class |
DelpArgument
This class models a DeLP argument which comprises of a set of defeasible rules (the support) and a literal (the conclusion).
|
class |
DelpFact
This class implements a fact in defeasible logic programming which encapsulates a literal.
|
class |
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.
|
class |
StrictRule
This class models a strict rule in defeasible logic programming.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractGraphLdoModality
Provides common functionalities for the graph-based modalities in LDO.
|
class |
AbstractLdoModality
Provides common functionalities for all modalities in LDO.
|
class |
LdoArgument
This class represents an argument in ldo.
|
class |
LdoAssociativeFormula
This class captures the common functionalities of formulas with an associative
operation like conjunction, disjunction, etc.
|
class |
LdoBoxModality |
class |
LdoConjunction
This class represents a conjunction in ldo logic.
|
class |
LdoDiamondModality |
class |
LdoDisjunction
This class represents a disjunction in ldo logic.
|
class |
LdoFormula
This abstract class specifies the general methods of all Ldo-formulas
(LDO - Logic of dialectical outcomes, cf.
|
class |
LdoGraphBoxModality |
class |
LdoGraphDiamondModality |
class |
LdoNegation
This class models classical negation of ldo logic.
|
class |
LdoRelation
Creates a relational formula, i.e.
|
Modifier and Type | Method and Description |
---|---|
Formula |
AbstractDungParser.parseFormula(java.io.Reader reader) |
Modifier and Type | Interface and Description |
---|---|
interface |
DungEntity
This interface captures common methods of arguments and attacks of
abstract argumentation theories.
|
Modifier and Type | Class and Description |
---|---|
class |
Argument
This class models an argument used by Dung's abstract argumentation theory and is just described by its name.
|
class |
Attack
This class models an attack between two arguments.
|
Modifier and Type | Class and Description |
---|---|
class |
ArgumentStructure
This class models an argument structure, i.e.
|
class |
BasicArgument
This class models a basic argument in structured argumentation frameworks, i.e.
|
Modifier and Type | Interface and Description |
---|---|
interface |
BaseContractionOperator<T extends Formula>
This is the interface for a classic belief base contraction operator, ie.
|
interface |
BaseExpansionOperator<T extends Formula>
This is the interface for a classic belief base expansion operator, ie.
|
interface |
BaseRevisionOperator<T extends Formula>
This is the interface for a classic belief base revision operator, ie.
|
class |
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.
|
class |
CredibilityRevisionIterative<T extends Formula>
Implements the list based method of the Revision interface by iterative calling
the revision method which revise two belief bases.
|
class |
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.
|
class |
DefaultBaseExpansionOperator<T extends Formula>
This class implements the default base expansion operator, ie.
|
class |
DefaultMultipleBaseExpansionOperator<T extends Formula>
This class implements the default multiple base expansion operator, ie.
|
class |
MultipleBaseContractionOperator<T extends Formula>
This is the interface for a classic multiple belief base contraction operator, ie.
|
class |
MultipleBaseExpansionOperator<T extends Formula>
This is the interface for a classic multiple belief base expansion operator, ie.
|
class |
MultipleBaseRevisionOperator<T extends Formula>
This is the interface for a classic multiple belief base revision operator, ie.
|
Modifier and Type | Class and Description |
---|---|
private static class |
RevisionComparePresenter.MockFormula
Mock formula used for functional test.
|
Modifier and Type | Field and Description |
---|---|
protected javax.swing.JList<java.util.Collection<? extends Formula>> |
RevisionCompareView.lstBeliefBases |
private javax.swing.DefaultListModel<java.util.Collection<? extends Formula>> |
RevisionCompareView.lstModel |
Modifier and Type | Method and Description |
---|---|
private <T extends Formula> |
RevisionCompareView.revision(BaseRevisionOperator<T> op)
Helper method: Runs a revision on BaseRevisionOperator interfaces which only allows the revision with one
formula.
|
private <T extends Formula> |
RevisionCompareView.revision(CredibilityRevision<T> op)
Helper method: Runs a revision using the credibility revision operator interface.
|
private <T extends Formula> |
RevisionCompareView.revision(MultipleBaseRevisionOperator<T> op)
Helper method: Runs a revision of using multiple belief bases with the MultipleBaseRevisionOperator.
|
Modifier and Type | Method and Description |
---|---|
java.util.Collection<? extends Formula> |
RevisionComparePresenter.FileHandler.load(java.io.File file) |
java.util.Collection<? extends Formula> |
RevisionComparePresenter.DefaultFileHandler.load(java.io.File file) |
private <T extends Formula> |
RevisionCompareView.revision(BaseRevisionOperator<T> op)
Helper method: Runs a revision on BaseRevisionOperator interfaces which only allows the revision with one
formula.
|
private <T extends Formula> |
RevisionCompareView.revision(CredibilityRevision<T> op)
Helper method: Runs a revision using the credibility revision operator interface.
|
private <T extends Formula> |
RevisionCompareView.revision(MultipleBaseRevisionOperator<T> op)
Helper method: Runs a revision of using multiple belief bases with the MultipleBaseRevisionOperator.
|
Modifier and Type | Method and Description |
---|---|
void |
RevisionCompareModel.addBeliefbase(java.util.Collection<? extends Formula> beliefBase)
Adds a belief base to the end of the ordered list of belief bases.
|
Modifier and Type | Interface and Description |
---|---|
interface |
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.
|
class |
KernelContractionOperator<T extends Formula>
This class implements kernel contraction for belief bases [Hansson:2001].
|
class |
RandomIncisionFunction<T extends Formula>
This class implements an incision function that just randomly
selects a minimal incision.
|
Modifier and Type | Class and Description |
---|---|
class |
CrMasBeliefSet<T extends Formula>
This class represents belief sets for credibility-based agents multi-agent systems.
|
class |
CrMasRevisionWrapper<T extends Formula>
This class is a wrapper for a revision for formulas of type T that is
used to revise information objects.
|
class |
InformationObject<T extends Formula>
This class represents a formula annotated with the source of the formula.
|
Modifier and Type | Class and Description |
---|---|
class |
InformationObject<T extends Formula>
This class represents a formula annotated with the source of the formula.
|
Modifier and Type | Field and Description |
---|---|
private T |
InformationObject.formula
The formula of this information object
|
Modifier and Type | Class and Description |
---|---|
class |
MultipleSelectiveRevisionOperator<T extends Formula>
This class implements a multiple selective revision operator following [Kruempelmann:2011,Ferme:1999].
|
interface |
MultipleTransformationFunction<T extends Formula>
This interface represents a multiple transformation function for selective revision [Kruempelmann:2011,Ferme:1999].
|
class |
SelectiveRevisionOperator<T extends Formula>
This class implements a selective revision operator following [Ferme:1999].
|
interface |
TransformationFunction<T extends Formula>
This interface represents a transformation function for selective revision [Ferme:1999].
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractInterpretation<B extends BeliefBase,S extends Formula>
An abstract interpretation for some logical language.
|
class |
BeliefSet<T extends Formula>
This class models a belief set, i.e.
|
interface |
BeliefSetIterator<S extends Formula,T extends BeliefSet<S>>
Classes implementing this interface are able to enumerate
belief sets.
|
class |
BeliefSetSampler<R extends Formula,S extends BeliefSet<R>>
This abstract class models a random sampler for belief sets.
|
class |
FormulaSampler<T extends Formula>
This abstract class models a sampler for formulas.
|
interface |
Interpretation<B extends BeliefBase,S extends Formula>
An interpretation for some logical language.
|
interface |
InterpretationIterator<S extends Formula,B extends BeliefBase,T extends Interpretation<B,S>>
An iterator over interpretations.
|
class |
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.
|
class |
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.
|
interface |
KernelProvider<T extends Formula>
Classes implementing this interface are able to provide kernels (=minimal proofs).
|
interface |
ModelProvider<S extends Formula,B extends BeliefBase,T extends Interpretation<B,S>>
Instances of this interface model reasoner that determine the (selected) models
for a given set of formulas.
|
interface |
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.
|
interface |
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.
|
interface |
Reasoner<O,B extends BeliefBase,F extends Formula>
The general interface for objects that are able to query a belief base
with some formula.
|
Modifier and Type | Method and Description |
---|---|
abstract Formula |
Parser.parseFormula(java.io.Reader reader)
Parses the given reader into a formula of the given type.
|
Formula |
Parser.parseFormula(java.lang.String text)
Parses the given text into a formula of the given type.
|
Formula |
Parser.parseFormulaFromFile(java.lang.String filename)
Parses the file of the given filename into a formula of the given type.
|
Modifier and Type | Method and Description |
---|---|
InterpretationIterator<S,B,T> |
InterpretationIterator.reset(java.util.Collection<? extends Formula> formulas)
Initializes a new reseted iterator for the given signature derived from
the given set of formulas.
|
Modifier and Type | Class and Description |
---|---|
class |
DrasticDistance<T extends Interpretation<B,S>,B extends BeliefBase,S extends Formula>
This class models the drastic distance measure between interpretations,
see [Grant, Hunter.
|
interface |
InterpretationDistance<T extends Interpretation<B,S>,B extends BeliefBase,S extends Formula>
Classes implementing this interface represent distance functions
between two interpretations.
|
Modifier and Type | Interface and Description |
---|---|
interface |
Postulate<S extends Formula>
Models a general (rationality) postulate, i.e.
|
interface |
PostulateEvaluatable<S extends Formula>
Classes implementing this interface can be evaluated
wrt.
|
class |
PostulateEvaluationReport<S extends Formula>
Summarises the results of a postulate evaluation.
|
class |
PostulateEvaluator<S extends Formula,T extends BeliefSet<S>>
Evaluates some approach (reasoner, measure, etc.) wrt.
|
Modifier and Type | Class and Description |
---|---|
class |
DefaultFormulaStream<S extends Formula>
This class models a default stream on the formulas of a given collection.
|
interface |
FormulaStream<S extends Formula>
This interface models a stream on formulas.
|
Modifier and Type | Interface and Description |
---|---|
interface |
Rule<C extends Formula,P extends Formula>
This interface models a general rule, i.e.
|
interface |
Rule<C extends Formula,P extends Formula>
This interface models a general rule, i.e.
|
Modifier and Type | Interface and Description |
---|---|
interface |
Rule<C extends Formula,P extends Formula>
This interface models a general rule, i.e.
|
Modifier and Type | Method and Description |
---|---|
Formula |
Derivation.getConclusion()
Returns the conclusion of this derivation.
|
Modifier and Type | Method and Description |
---|---|
java.util.Set<Formula> |
RuleSet.getConclusions()
Returns all conclusions of all rules of this rule set.
|
java.util.Set<Formula> |
RuleSet.getPremises()
Returns all premises appearing in this rule set.
|
Modifier and Type | Method and Description |
---|---|
static <S extends Rule<?,?>> |
Derivation.allDerivations(java.util.Collection<? extends S> rules,
Formula conclusion)
Returns the set of all possible derivations with the given
conclusion from the set of rules.
|
java.util.Set<T> |
RuleSet.getRulesWithConclusion(Formula f)
Returns all rules this set with the given conclusion
|
RuleSet<T> |
RuleSet.getSyntacticModule(Formula f)
Returns the maximal subset of this rule set that is closed under
"syntactic" neighbourhood relationship for the given formula.
|
Modifier and Type | Class and Description |
---|---|
class |
Conditional
This class represents a basic conditional (B|A) with formulas A,B.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractBeliefSetConsistencyTester<S extends Formula>
Classes extending this abstract class are capable of testing
whether a given belief set is consistent.
|
class |
AbstractMusEnumerator<S extends Formula>
Abstract implementation for MUes enumerators.
|
interface |
BeliefSetConsistencyTester<S extends Formula>
Classes extending this abstract class are capable of testing
whether a given belief set is consistent.
|
class |
BeliefSetInconsistencyMeasure<S extends Formula>
Classes extending this abstract class represent inconsistency measures
on belief sets.
|
class |
CcInconsistencyMeasure<S extends Formula>
This class implements the inconsistency measure I_CC from
[Said Jabbour and Yue Ma and Badran Raddaoui.
|
interface |
ConsistencyWitnessProvider<B extends BeliefBase,S extends Formula>
Provides methods for returning some model (if it exists) of
a set of formulas.
|
class |
CspInconsistencyMeasure<S extends Formula>
This class implements the inconsistency measure I_CSP from
[Said Jabbour, Yue Ma, Badran Raddaoui, Lakhdar Sais, Yakoub Salhi.
|
interface |
CulpabilityMeasure<S extends Formula,T extends BeliefSet<S>>
Classes implementing this interface represent culpability measures, i.e.
|
class |
DfInconsistencyMeasure<S extends Formula>
This class implements the family of "Measures of the Degree of Inconsistency" from
[Mu,Liu,Jin, Bell.
|
class |
DHitInconsistencyMeasure<T extends Interpretation<B,S>,B extends BeliefBase,S extends Formula>
This class implements the d-hit inconsistency measure from [Grant, Hunter.
|
class |
DMaxInconsistencyMeasure<T extends Interpretation<B,S>,B extends BeliefBase,S extends Formula>
This class implements the d-max inconsistency measure from [Grant, Hunter.
|
class |
DrasticInconsistencyMeasure<S extends Formula>
This class models the drastic inconsistency measure.
|
class |
DSumInconsistencyMeasure<T extends Interpretation<B,S>,B extends BeliefBase,S extends Formula>
This class implements the d-sum inconsistency measure from [Grant, Hunter.
|
class |
EtaInconsistencyMeasure<B extends BeliefBase,S extends Formula>
This class implements the Eta-inconsistency measure, cf.
|
class |
HsInconsistencyMeasure<B extends BeliefBase,S extends Formula>
This class implements the Hitting Set inconsistency measure as proposed in [Thimm, 2014, in preparation].
|
class |
IsInconsistencyMeasure<S extends Formula>
This class implements the inconsistency measure I_CSP from
[Said Jabbour.
|
class |
MaInconsistencyMeasure<S extends Formula>
This class models the I_M inconsistency measure from e.g.
|
class |
McscInconsistencyMeasure<S extends Formula>
This class implements the approach of [Meriem Ammoura, Badran Raddaoui, Yakoub Salhi, Brahim Oukacha.
|
class |
MicInconsistencyMeasure<S extends Formula>
This class models the MI^C inconsistency measure.
|
class |
MiInconsistencyMeasure<S extends Formula>
This class models the MI inconsistency measure.
|
interface |
MusEnumerator<S extends Formula>
Interface for classes enumerating MUSes (minimal unsatisfiable sets) and
MCSs (maximal consistent sets).
|
class |
NaiveMusEnumerator<S extends Formula>
A simple approach to compute minimal inconsistent subsets and maximal
consistent subsets by exhaustive search.
|
class |
NConsInconsistencyMeasure<S extends Formula>
This class implements an inconsistency measure based on "n-consistency" proposed in
[Doder,Raskovic,Markovic,Ognjanovic.
|
class |
NormalizedMicInconsistencyMeasure<S extends Formula>
This class models the normalized MI^C inconsistency measure, see [PhD thesis, Thimm].
|
class |
NormalizedMiInconsistencyMeasure<S extends Formula>
This class models the normalized MI inconsistency measure, see [PhD thesis, Thimm].
|
class |
PrInconsistencyMeasure<S extends Formula>
This class models the P inconsistency measure from e.g.
|
class |
ShapleyCulpabilityMeasure<S extends Formula,T extends BeliefSet<S>>
This class implements the Shapley culpability measure.
|
Modifier and Type | Class and Description |
---|---|
class |
DefaultStreamBasedInconsistencyMeasure<S extends Formula>
Implements a stream-based inconsistency measure on a given class of
inconsistency measurement processes.
|
class |
InconsistencyMeasurementProcess<S extends Formula>
The actual process of an inconsistency measure on streams.
|
class |
StreamBasedInconsistencyMeasure<S extends Formula>
General interface for inconsistency measures working on streams.
|
class |
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.
|
Modifier and Type | Field and Description |
---|---|
protected Formula |
InconsistencyUpdateEvent.f |
(package private) S |
InconsistencyMeasurementProcess.UpdateCallee.formula |
Constructor and Description |
---|
InconsistencyUpdateEvent(StreamBasedInconsistencyMeasure<?> measure,
InconsistencyMeasurementProcess<?> process,
java.lang.Double inconsistencyValue,
Formula f)
Creates a new event with the given parameters.
|
Modifier and Type | Class and Description |
---|---|
class |
AssociativeFormulaSupport<T extends SimpleLogicalFormula>
This class provides common implementation for associative formulas
that are formulas which consists of several other formulas.
|
class |
ComplexLogicalFormulaAdapter
Abstract base class for ComplexLogicalFormula, that are formulas which
implement substitute(), exchange(), getTerms(), isGround() and isWellFormed()
and therefore use terms to describe themself.
|
class |
RelationalFormula
This is the abstract base class for relational formulas,
i.e.
|
Modifier and Type | Interface and Description |
---|---|
interface |
LogicProgram<C extends Formula,P extends Formula,T extends Rule<?,?>>
An interface for a logic program, which is a set of rules.
|
interface |
LogicProgram<C extends Formula,P extends Formula,T extends Rule<?,?>>
An interface for a logic program, which is a set of rules.
|
Modifier and Type | Interface and Description |
---|---|
interface |
AssociativeFormula<T extends SimpleLogicalFormula>
This interfaces describes associative formulas like a disjunction or
a conjunction.
|
interface |
Atom
An atomic language construct, linked to its predicate
|
interface |
ClassicalFormula
This interface models a classical formula, i.e.
|
interface |
ComplexLogicalFormula
A complex logical formula can contain arguments referred as terms, this
interface provides methods to substitute and exchange those terms.
|
interface |
Conjuctable
Formulas implementing this interface can be connected by using
AND.
|
interface |
Disjunctable
Formulas implementing this interface can be connected using
OR.
|
interface |
Invertable
Formulas implementing this interface have a
complement
|
interface |
QuantifiedFormula
Interface for a QuantifiedFormula with a set of quantified variables
implementing an all- or exist-quantor for example.
|
interface |
SimpleLogicalFormula
A formula of a logical language
|
Modifier and Type | Class and Description |
---|---|
class |
Axiom
This abstract class provides the base for terminological and assertional axioms
|
Modifier and Type | Method and Description |
---|---|
Formula |
TPTPParser.parseFormula(java.io.Reader reader) |
Formula |
FolParser.parseFormula(java.io.Reader reader) |
Modifier and Type | Method and Description |
---|---|
java.lang.String |
SpassFolReasoner.queryProof(FolBeliefSet kb,
Formula query)
Determines the answer wrt.
|
Modifier and Type | Class and Description |
---|---|
class |
AssociativeFOLFormula
This class captures the common functionalities first order associative formulas like conjunction,
disjunction, etc.
|
class |
Conjunction
The classical conjunction of first-order logic.
|
class |
Contradiction
A contradictory formula.
|
class |
Disjunction
The classical disjunction of first-order logic.
|
class |
Equivalence
The equivalence of first-order logic.
|
class |
ExistsQuantifiedFormula
Exists-quantified first-order logic formula.
|
class |
FOLAtom
An atom in first-order logic, i.e.
|
class |
FolFormula
The common abstract class for formulas of first-order logic.
|
class |
ForallQuantifiedFormula
For-All-quantified first-order logic formula.
|
class |
Implication
The implication of first-order logic.
|
class |
Negation
The classical negation of first-order logic.
|
class |
SpecialFormula
This class captures the common functionalities of the special
formulas tautology and contradiction.
|
class |
Tautology
A tautological formula.
|
Modifier and Type | Method and Description |
---|---|
Formula |
ModalParser.parseFormula(java.io.Reader reader) |
Modifier and Type | Method and Description |
---|---|
java.lang.String |
SPASSModalReasoner.queryProof(ModalBeliefSet kb,
Formula query)
Determines the answer wrt.
|
Modifier and Type | Method and Description |
---|---|
boolean |
ModalHerbrandInterpretation.satisfies(Formula formula,
java.util.Set<Interpretation<FolBeliefSet,FolFormula>> successors)
Checks whether this Herbrand interpretation satisfies
the given formula.
|
Modifier and Type | Class and Description |
---|---|
class |
ModalFormula
This class models a modal formula, i.e.
|
class |
Necessity
This class models the necessity modality.
|
class |
Possibility
This class models the possibility modality.
|
Modifier and Type | Class and Description |
---|---|
class |
MlnFormula
Instances of this class represent first-order formulas with a weight.
|
Modifier and Type | Class and Description |
---|---|
class |
ProbabilisticConditional
This class represents a probabilistic conditional of the form (B|A)[p]
with formulas A,B and a probability p.
|
Modifier and Type | Method and Description |
---|---|
InterpretationIterator<PropositionalFormula,PlBeliefSet,PossibleWorld> |
PossibleWorldIterator.reset(java.util.Collection<? extends Formula> formulas) |
Modifier and Type | Class and Description |
---|---|
class |
AssociativePropositionalFormula
This class captures the common functionalities of formulas with an associative
operation like conjunction, disjunction, etc.
|
class |
Proposition
This class represents a simple proposition in propositional logic.
|
class |
PropositionalFormula
This class represents the common ancestor for propositional formulae.
|
Modifier and Type | Class and Description |
---|---|
class |
RelationalConditional
Instances of this class represent relational conditionals.
|
Modifier and Type | Method and Description |
---|---|
Formula |
RdlParser.parseFormula(java.io.Reader reader) |
Modifier and Type | Class and Description |
---|---|
class |
DefaultRule
Models a default rule in Reiter's default logic, see [R.
|
Modifier and Type | Class and Description |
---|---|
class |
RelationalProbabilisticConditional
This class represents a relational probabilistic conditional, i.e.
|
Modifier and Type | Interface and Description |
---|---|
interface |
ConsolidationOperator<T extends Formula>
This interface represents an consolidation operator for belief bases
as defined in [KKI12].
|
class |
RemainderSets<T extends Formula>
This class represents the set of remainder sets constructed
from a belief base.
|
interface |
SelectionFunction<T extends Formula>
This interface models a general selection function for remainder sets
|
Modifier and Type | Method and Description |
---|---|
private <E extends Formula> |
SimpleRevisionCompareModel.runRevision(BaseRevisionOperator<E> op) |
private <E extends Formula> |
SimpleRevisionCompareModel.runRevision(MultipleBaseRevisionOperator<E> op) |
Modifier and Type | Interface and Description |
---|---|
interface |
DLPElement
This interface defines base methods every element of a
program has to provide.
|
interface |
DLPLiteral
This interface defines common functionality for an ELP literal.
|
Modifier and Type | Class and Description |
---|---|
class |
Aggregate
This class represents an aggregate function.
|
class |
Arithmetic
This class implements the Arithmetic semantic given
by the DLV Manual.
|
class |
Comparative
This class implements comparative predicates as described in
the DLV manual.
|
class |
DLPAtom
This class models an atom, which is a basic structure for
building literals and rules for logic programs.
|
class |
DLPElementAdapter
This class acts as an abstract base class for classes that implement
the ELPElement interface.
|
class |
DLPHead
This formula represents the head of an disjunctive rule which is a
disjunction of ELP literals.
|
class |
DLPNeg
This class models strict negation for atoms.
|
class |
DLPNot
This class models a default negated literal.
|
class |
Rule
This class models a rule for a disjunctive logic program.
|
Modifier and Type | Class and Description |
---|---|
class |
NLPNot
A default negation of a first order formula, nested logic programs
only allow not quantified formulas.
|
class |
NLPRule
A rule of a nested logic program.
|