Modifier and Type | Class and Description |
---|---|
class |
DefeasibleRule
This class models a defeasible rule in defeasible logic programming.
|
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 |
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 |
Constant
A Constant represents an constant object in the world of
a logical language.
|
class |
FunctionalTerm
A functional term in a logic language, i.e.
|
class |
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.
|
class |
Sort
A sort of first-order logic.
|
class |
StringTerm
This class represents terms which are objects identified by a
string.
|
class |
TermAdapter<T>
Abstract base class implementing the substitute(), getSort(), getTerms(), and
containsTermsOfType() methods in a way it is useful for terms.
|
class |
Variable
A Variable is a placeholder for Constants in a generic formula of
an logic language.
|
Modifier and Type | Interface and Description |
---|---|
interface |
ComplexLogicalFormula
A complex logical formula can contain arguments referred as terms, this
interface provides methods to substitute and exchange those terms.
|
interface |
QuantifiedFormula
Interface for a QuantifiedFormula with a set of quantified variables
implementing an all- or exist-quantor for example.
|
interface |
Term<T>
A term of a logical language, that can be given as argument for logical constructs
like atoms or functors.
|
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 |
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 |
ExistsQuantifiedFormula |
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 formula.
|
class |
Negation
The classical negation of first-order logic.
|
class |
QuantifiedFormula
The common parent of exists and forall quantified formulas, which contains common
functionalities.
|
class |
RelationalFormula
This interface models a relational formula, i.e.
|
class |
SpecialFormula
This class captures the common functionalities of the special
formulas tautology and contradiction.
|
class |
Tautology
A tautological formula.
|
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 |
RelationalConditional
Instances of this class represent relational conditionals.
|
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 |
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 acts as abstract base class for classes 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 |
ListTerm
this class models a list term that can be used for
dlv complex programs.
|
class |
Rule
This class models a rule for a disjunctive logic program.
|
class |
SetTerm
this class models a set term, which can be used
for sets in dlv complex programs.
|
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.
|