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