Modifier and Type | Method and Description |
---|---|
private java.lang.String |
CTransitionSystemCalculator.getLiteralString(FolFormula f,
int t,
boolean negated)
Utility function representing a single literal either in a direct manner or
using default negation.
|
private java.lang.String |
CTransitionSystemCalculator.getRuleBodyString(FolFormula f,
int t,
boolean negated)
Calculates the representation of an inner formula of a causal rule
according to the translation in
"Representing Transition Systems by Logic Programs.".
|
Modifier and Type | Method and Description |
---|---|
protected FolFormula |
CLawParser.parseFolFormula(java.lang.String s)
Parses a FolFormula from a string using the FolParser class
|
Modifier and Type | Field and Description |
---|---|
protected FolFormula |
DynamicLaw.afterFormula |
protected FolFormula |
CLaw.headFormula |
protected FolFormula |
CLaw.ifFormula |
Modifier and Type | Method and Description |
---|---|
FolFormula |
DynamicLaw.getAfterFormula()
Returns the afterFormula of this causal law.
|
FolFormula |
CLaw.getHeadFormula()
Returns the headFormula of this causal law.
|
FolFormula |
CLaw.getIfFormula()
Returns the ifFormula of this causal law.
|
Modifier and Type | Method and Description |
---|---|
java.util.Set<FolFormula> |
StaticLaw.getFormulas() |
java.util.Set<FolFormula> |
DynamicLaw.getFormulas() |
abstract java.util.Set<FolFormula> |
CLaw.getFormulas()
Returns the set of formulas contained in this causal law, e.g.
|
Modifier and Type | Method and Description |
---|---|
protected boolean |
CLaw.isConjunctiveClause(FolFormula pl)
a conjunctive clause is either a literal or a conjunction of literals.
|
private void |
DynamicLaw.setAfterFormula(FolFormula afterFormula)
Sets the afterFormula of this causal law
|
private void |
CLaw.setHeadFormula(FolFormula headFormula)
Sets the headFormula of this causal law
|
private void |
CLaw.setIfFormula(FolFormula ifFormula)
Sets the IfFormula of this causal law
|
Constructor and Description |
---|
CLaw(FolFormula headFormula)
Creates a causal law of the form caused headFormula if True
|
CLaw(FolFormula headFormula,
FolFormula ifFormula)
Creates a causal law of the form caused headFormula if ifFormula
|
CLaw(FolFormula headFormula,
FolFormula ifFormula,
java.util.Set<GroundingRequirement> requirements)
Creates a causal law of the form caused headFormula if ifFormula requires
requirements
|
CLaw(FolFormula headFormula,
java.util.Set<GroundingRequirement> requirements)
Creates a causal law of the form caused headFormula if True requires
requirements
|
DynamicLaw(FolFormula headFormula,
FolFormula afterFormula)
Creates a new dynamic law of the form caused headFormula after
afterFormula
|
DynamicLaw(FolFormula headFormula,
FolFormula ifFormula,
FolFormula afterFormula)
Creates a new dynamic law of the form: caused headFormula if ifFormula
after afterFormula
|
DynamicLaw(FolFormula headFormula,
FolFormula ifFormula,
FolFormula afterFormula,
java.util.Set<GroundingRequirement> requirements)
Creates a new dynamic law of the form: caused headFormula if ifFormula
after afterFormula requires requirements
|
DynamicLaw(FolFormula headFormula,
FolFormula afterFormula,
java.util.Set<GroundingRequirement> requirements)
Creates a new dynamic law of the form caused headFormula after
afterFormula requires requirements
|
StaticLaw(FolFormula headFormula)
Creates an empty static law of the form caused headFormula if True
|
StaticLaw(FolFormula headFormula,
FolFormula ifFormula)
Creates an empty static law of the form caused headFormula if ifFormula
|
StaticLaw(FolFormula headFormula,
FolFormula ifFormula,
java.util.Set<GroundingRequirement> requirements)
Creates an empty static law of the form caused headFormula if ifFormula
requires requirements
|
StaticLaw(FolFormula headFormula,
java.util.Set<GroundingRequirement> requirements)
Creates an empty static law of the form caused headFormula if True
requires requirements
|
Modifier and Type | Method and Description |
---|---|
private java.util.Set<FolFormula> |
SActionQuerySatisfactionTester.getStateParts(FolFormula formula)
Calculates the set of all possible parts of the propositional formula
given.
|
Modifier and Type | Method and Description |
---|---|
private java.lang.String |
SActionQuerySatisfactionTester.getStatePartRules(FolFormula statePart)
This function translates a propositional formula into a logic program
according to certain rules.
|
private java.util.Set<FolFormula> |
SActionQuerySatisfactionTester.getStateParts(FolFormula formula)
Calculates the set of all possible parts of the propositional formula
given.
|
Modifier and Type | Field and Description |
---|---|
protected FolFormula |
QueryProposition.formula |
Modifier and Type | Method and Description |
---|---|
FolFormula |
QueryProposition.getInnerFormula()
Returns the inner formula of this query proposition, e.g.
|
Modifier and Type | Method and Description |
---|---|
java.util.Set<FolFormula> |
SActionQuery.getInnerFormulas()
Returns all inner formulas that are contained in query propositions
in this action query.
|
Constructor and Description |
---|
AlwaysQuery(FolFormula formula)
Creates a new always query with the given inner formula.
|
HoldsQuery(FolFormula formula)
Creates a new holds query with the given inner formula.
|
NecessarilyQuery(FolFormula formula)
Creates a new necessarily query with an empty action sequence.
|
NecessarilyQuery(FolFormula formula,
FolAction action)
Creates a new necessarily query with the given inner formula and a single
action.
|
NecessarilyQuery(FolFormula formula,
java.util.List<FolAction> actions)
Creates a new necessarily query with the given inner formula and list of
actions.
|
QueryProposition(FolFormula formula,
java.lang.String name)
Creates a new query proposition with the given formula and a unique name,
which is used by the base class.
|
Constructor and Description |
---|
ActionSignature(FolFormula f)
Creates a new Action Signature for a single first order formula.
|
Modifier and Type | Method and Description |
---|---|
FolFormula |
FolFormulaGenerator.getRuleFormula(DefeasibleInferenceRule<FolFormula> r) |
Modifier and Type | Method and Description |
---|---|
FolFormula |
FolFormulaGenerator.getRuleFormula(DefeasibleInferenceRule<FolFormula> r) |
Modifier and Type | Field and Description |
---|---|
private static FolFormula |
TestArguments.FOL_FLIES_TINA |
private static FolFormula |
TestArguments.FOL_NOT_FLIES_TINA |
Modifier and Type | Field and Description |
---|---|
(package private) static java.util.Comparator<FolFormula> |
Utilities.compareLiterals
Compare DeLP literals as they arise in rules, i.e.,
~B < A (negation is always smaller)
A < B (atoms = predicates are sorted by predicate name first...
|
Modifier and Type | Method and Description |
---|---|
java.util.Set<FolFormula> |
DefeasibleLogicProgram.getStrictClosure()
Computes the strict closure of the program, i.e., the set of all strictly derivable literals.
|
java.util.Set<FolFormula> |
DefeasibleLogicProgram.getStrictClosure(java.util.Set<FolFormula> literals)
Computes the strict closure of the program, i.e., the set of all strictly derivable literals.
|
java.util.Set<FolFormula> |
DefeasibleLogicProgram.getStrictClosure(java.util.Set<FolFormula> literals,
java.util.Set<DefeasibleRule> defeasibleRules)
Computes the strict closure of the program, i.e., the set of all strictly derivable literals.
|
java.util.Set<FolFormula> |
DefeasibleLogicProgram.getStrictClosure(java.util.Set<FolFormula> literals,
java.util.Set<DefeasibleRule> defeasibleRules,
boolean usefacts)
Computes the strict closure of the program, i.e., the set of all strictly derivable literals.
|
Modifier and Type | Method and Description |
---|---|
java.util.Set<DelpRule> |
DefeasibleLogicProgram.getRulesWithHead(FolFormula l)
Returns all defeasible and strict rules appearing in this program with the given literal as head
|
Modifier and Type | Method and Description |
---|---|
boolean |
DefeasibleLogicProgram.disagree(java.util.Set<FolFormula> literals)
Checks whether the given set of literals disagree with respect to the strict part of this program.
|
java.util.Set<FolFormula> |
DefeasibleLogicProgram.getStrictClosure(java.util.Set<FolFormula> literals)
Computes the strict closure of the program, i.e., the set of all strictly derivable literals.
|
java.util.Set<FolFormula> |
DefeasibleLogicProgram.getStrictClosure(java.util.Set<FolFormula> literals,
java.util.Set<DefeasibleRule> defeasibleRules)
Computes the strict closure of the program, i.e., the set of all strictly derivable literals.
|
java.util.Set<FolFormula> |
DefeasibleLogicProgram.getStrictClosure(java.util.Set<FolFormula> literals,
java.util.Set<DefeasibleRule> defeasibleRules,
boolean usefacts)
Computes the strict closure of the program, i.e., the set of all strictly derivable literals.
|
Modifier and Type | Method and Description |
---|---|
FolFormula |
DelpParser.Formula(FolSignature signature) |
FolFormula |
DelpParser.Literal(DefeasibleLogicProgram delp,
FolSignature signature) |
Modifier and Type | Method and Description |
---|---|
private java.util.Set<java.util.Set<FolFormula>> |
GeneralizedSpecificity.ntActSets(ArgumentCompletion argument)
Computes the activation sets of the given argument completion.
|
private java.util.Set<java.util.Set<FolFormula>> |
GeneralizedSpecificity.ntActSets(java.util.Set<ArgumentCompletion> argumentCompletions)
Computes the activation sets of all given argument completions
|
Modifier and Type | Method and Description |
---|---|
java.util.Set<DelpRule> |
ArgumentCompletion.getRulesWithHead(FolFormula l) |
Modifier and Type | Method and Description |
---|---|
private boolean |
GeneralizedSpecificity.actSetTest(java.util.Set<java.util.Set<FolFormula>> ntActSets,
DelpArgument arg,
DefeasibleLogicProgram delp)
Test whether all given activation sets activate the given argument.
|
private boolean |
GeneralizedSpecificity.isActivated(DelpArgument arg,
java.util.Set<FolFormula> activationSet,
DefeasibleLogicProgram delp)
Test whether the given argument is activated by the given activation set.
|
Modifier and Type | Field and Description |
---|---|
private FolFormula |
DelpArgument.conclusion
The conclusion of this argument (must be a literal)
|
protected FolFormula |
DelpRule.head
The head of the rule (this must be a literal).
|
Modifier and Type | Field and Description |
---|---|
protected java.util.Set<FolFormula> |
DelpRule.body
The body of the rule (these must be a literals).
|
Modifier and Type | Method and Description |
---|---|
FolFormula |
DelpRule.getConclusion() |
FolFormula |
DelpArgument.getConclusion()
returns the conclusion of this argument
|
Modifier and Type | Method and Description |
---|---|
java.util.Set<FolFormula> |
DelpArgument.getAttackOpportunities(DefeasibleLogicProgram delp)
Computes the set of literals that disagree with the conclusion of a subargument of this argument
|
java.util.Collection<? extends FolFormula> |
DelpRule.getPremise() |
Modifier and Type | Method and Description |
---|---|
void |
DelpRule.addPremise(FolFormula premise) |
DelpArgument |
DelpArgument.getDisagreementSubargument(FolFormula lit,
DefeasibleLogicProgram delp)
Computes the disagreement subargument of this argument for the given literal
|
java.util.Set<DelpRule> |
DelpArgument.getRulesWithHead(FolFormula l)
Returns all defeasible rules of the support of this argument with the given literal as head
|
void |
DelpRule.setConclusion(FolFormula conclusion) |
Modifier and Type | Method and Description |
---|---|
void |
DelpRule.addPremises(java.util.Collection<? extends FolFormula> premises) |
boolean |
DelpRule.isApplicable(java.util.Collection<? extends FolFormula> literals)
Checks whether this rule is applicaple in the given context
|
Constructor and Description |
---|
DefeasibleRule(FolFormula head,
java.util.Set<FolFormula> body)
Initializes the defeasible rule with the given parameters
|
DelpArgument(FolFormula conclusion)
constructor; initializes the conclusion of this argument with the given literal
|
DelpArgument(java.util.Set<DefeasibleRule> support,
FolFormula conclusion)
constructor; initializes this argument with the given parameters
|
DelpFact(FolFormula literal)
Default constructor; initializes this fact with the given literal
|
DelpRule(FolFormula head,
java.util.Collection<? extends FolFormula> body)
Default constructor; initializes head and body of the rule
|
StrictRule(FolFormula head,
java.util.Set<FolFormula> body)
Default constructor; initializes head and body of the strict rule
|
Constructor and Description |
---|
DefeasibleRule(FolFormula head,
java.util.Set<FolFormula> body)
Initializes the defeasible rule with the given parameters
|
DelpRule(FolFormula head,
java.util.Collection<? extends FolFormula> body)
Default constructor; initializes head and body of the rule
|
StrictRule(FolFormula head,
java.util.Set<FolFormula> body)
Default constructor; initializes head and body of the strict rule
|
Modifier and Type | Method and Description |
---|---|
static boolean |
ClassicalInference.equivalent(FolFormula f1,
FolFormula f2)
Tests naively whether two fol formulas are equivalent
|
Constructor and Description |
---|
FolBeliefSet(java.util.Set<FolFormula> formulas)
Creates a new first-order knowledge base with the given set of formulas.
|
Modifier and Type | Method and Description |
---|---|
FolFormula |
FolParserB.formula(FolSignature signature) |
private FolFormula |
FolParserB.helper(FolFormula form,
Pair<java.lang.Integer,FolFormula> exform) |
private FolFormula |
FolParser.parseAtomic(java.util.List<java.lang.Object> l)
Parses a simple formula as a list of String tokens or formulas into a fol formula.
|
private FolFormula |
FolParser.parseConjunction(java.util.List<java.lang.Object> l)
Parses a simple conjunction as a list of String tokens or formulas into a fol formula.
|
private FolFormula |
FolParser.parseDisjunction(java.util.List<java.lang.Object> l)
Parses a disjunction as a list of String tokens or formulas into a fol formula.
|
private FolFormula |
FolParser.parseNegation(java.util.List<java.lang.Object> l)
Parses a simple formula as a list of String tokens or formulas into a fol formula.
|
private FolFormula |
FolParser.parseQuantification(java.util.List<java.lang.Object> l)
Parses a quantified formula as a list of String tokens or formulas.
|
Modifier and Type | Method and Description |
---|---|
Pair<java.lang.Integer,FolFormula> |
FolParserB.formulaex(FolSignature signature) |
Modifier and Type | Method and Description |
---|---|
private FolFormula |
FolParserB.helper(FolFormula form,
Pair<java.lang.Integer,FolFormula> exform) |
Modifier and Type | Method and Description |
---|---|
private FolFormula |
FolParserB.helper(FolFormula form,
Pair<java.lang.Integer,FolFormula> exform) |
Modifier and Type | Method and Description |
---|---|
boolean |
Prover9.equivalent(FolBeliefSet kb,
FolFormula a,
FolFormula b) |
boolean |
NaiveProver.equivalent(FolBeliefSet kb,
FolFormula a,
FolFormula b) |
abstract boolean |
FolTheoremProver.equivalent(FolBeliefSet kb,
FolFormula a,
FolFormula b) |
boolean |
EProver.equivalent(FolBeliefSet kb,
FolFormula a,
FolFormula b) |
boolean |
Prover9.query(FolBeliefSet kb,
FolFormula query) |
boolean |
NaiveProver.query(FolBeliefSet kb,
FolFormula query) |
abstract boolean |
FolTheoremProver.query(FolBeliefSet kb,
FolFormula query)
This method determines the answer of the given query
wrt.
|
boolean |
EProver.query(FolBeliefSet kb,
FolFormula query) |
Modifier and Type | Method and Description |
---|---|
boolean |
HerbrandInterpretation.satisfies(java.util.Set<FolFormula> formulas)
Checks whether this Herbrand interpretation satisfies each of
the formulas in the given set of first-order formulas.
|
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 |
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 |
SpecialFormula
This class captures the common functionalities of the special
formulas tautology and contradiction.
|
class |
Tautology
A tautological formula.
|
Modifier and Type | Field and Description |
---|---|
private FolFormula |
QuantifiedFormula.folFormula
The folFormula this quantified folFormula ranges over.
|
private FolFormula |
Negation.folFormula |
Modifier and Type | Method and Description |
---|---|
abstract FolFormula |
FolFormula.clone() |
FolFormula |
SpecialFormula.collapseAssociativeFormulas() |
FolFormula |
Negation.collapseAssociativeFormulas() |
FolFormula |
ForallQuantifiedFormula.collapseAssociativeFormulas() |
FolFormula |
FOLAtom.collapseAssociativeFormulas() |
FolFormula |
ExistsQuantifiedFormula.collapseAssociativeFormulas() |
FolFormula |
QuantifiedFormula.getFormula()
Returns the folFormula this quantified folFormula ranges over
|
FolFormula |
Negation.getFormula() |
FolFormula |
SpecialFormula.substitute(Term<?> v,
Term<?> t) |
abstract FolFormula |
FolFormula.substitute(Term<?> v,
Term<?> t) |
FolFormula |
FolFormula.toDnf()
Makes a disjunctive normal form of this formula.
|
FolFormula |
SpecialFormula.toNnf() |
FolFormula |
Negation.toNnf() |
FolFormula |
ForallQuantifiedFormula.toNnf() |
abstract FolFormula |
FolFormula.toNnf()
Makes the negation normal form of this formula.
|
FolFormula |
FOLAtom.toNnf() |
FolFormula |
ExistsQuantifiedFormula.toNnf() |
FolFormula |
Disjunction.toNnf() |
FolFormula |
Conjunction.toNnf() |
Modifier and Type | Method and Description |
---|---|
boolean |
FolSignature.isRepresentable(FolFormula folFormula)
Checks whether the given formula can be represented by this signature.
|
Constructor and Description |
---|
ExistsQuantifiedFormula(FolFormula folFormula,
Variable variable)
Creates a new exists-quantified formula with the given formula and variable.
|
ForallQuantifiedFormula(FolFormula folFormula,
Variable variable)
Creates a new for-all-quantified formula with the given formula and variable.
|
QuantifiedFormula(FolFormula folFormula,
Variable variable)
Creates a new quantified folFormula with the given folFormula and variable.
|
Modifier and Type | Method and Description |
---|---|
void |
TptpWriter.printEquivalence(FolFormula a,
FolFormula b) |
void |
Prover9Writer.printEquivalence(FolFormula a,
FolFormula b) |
void |
FolWriter.printEquivalence(FolFormula a,
FolFormula b)
Prints an Equivalence
|
void |
TptpWriter.printQuery(FolFormula query) |
void |
Prover9Writer.printQuery(FolFormula query) |
void |
FolWriter.printQuery(FolFormula query)
Prints formatted representation of a Query.
|
Modifier and Type | Field and Description |
---|---|
private java.util.Map<FolFormula,java.lang.Double> |
IteratingMlnReasoner.archive
For archiving previous results.
|
Modifier and Type | Method and Description |
---|---|
protected double |
SimpleSamplingMlnReasoner.doQuery(FolFormula query) |
double |
NaiveMlnReasoner.doQuery(FolFormula query) |
protected double |
IteratingMlnReasoner.doQuery(FolFormula query) |
protected double |
ApproximateNaiveMlnReasoner.doQuery(FolFormula query) |
double |
AlchemyMlnReasoner.doQuery(FolFormula query) |
protected abstract double |
AbstractMlnReasoner.doQuery(FolFormula query)
Performs the actual querying.
|
protected int |
AbstractMlnReasoner.numberOfGroundSatisfactions(FolFormula formula,
HerbrandInterpretation hInt)
Computes the number of instantiations of the formula, wrt.
|
private java.io.File |
AlchemyMlnReasoner.writeAlchemyMlnFile(MarkovLogicNetwork mln,
FolSignature signature,
FolFormula formula)
Writes the given MLN wrt.
|
Modifier and Type | Field and Description |
---|---|
private FolFormula |
MlnFormula.formula
the first-order formula.
|
Modifier and Type | Method and Description |
---|---|
FolFormula |
MlnFormula.getFormula()
Returns the inner formula.
|
Constructor and Description |
---|
MlnFormula(FolFormula formula)
Creates a new strict MLN formula with the given formula.
|
MlnFormula(FolFormula formula,
java.lang.Double weight)
Creates a new MLN formula with the given formula and weight.
|
MlnFormula(FolFormula formula,
Probability p)
Creates a new MLN formula and estimates its weight w by the given
probability p using the formula w = log(p/(1-p)*f) where "f" is the
ratio of the number of worlds not satisfying the formula and the
worlds satisfying the formula.
|
Modifier and Type | Method and Description |
---|---|
java.lang.Integer |
RelationalRankingFunction.rank(FolFormula formula)
Gets the rank of the given sentence (ground formula).
|
Modifier and Type | Field and Description |
---|---|
private FolFormula |
RelationalConditional.conclusion
The conclusion of the conditional.
|
private FolFormula |
RelationalConditional.premise
The premise of the conditional.
|
Modifier and Type | Method and Description |
---|---|
FolFormula |
RelationalConditional.getConclusion() |
Modifier and Type | Method and Description |
---|---|
java.util.Collection<? extends FolFormula> |
RelationalConditional.getPremise() |
Modifier and Type | Method and Description |
---|---|
void |
RelationalConditional.addPremise(FolFormula premise) |
void |
RelationalConditional.setConclusion(FolFormula conclusion) |
Modifier and Type | Method and Description |
---|---|
void |
RelationalConditional.addPremises(java.util.Collection<? extends FolFormula> premises) |
Constructor and Description |
---|
RelationalConditional(FolFormula conclusion)
Creates a new conditional with the given conclusion and
a tautological premise.
|
RelationalConditional(FolFormula premise,
FolFormula conclusion)
Creates a new conditional with the given premise and conclusion.
|
Modifier and Type | Method and Description |
---|---|
java.util.Collection<java.util.Collection<FolFormula>> |
NaiveDefaultReasoner.getAllExtensions() |
Modifier and Type | Method and Description |
---|---|
(package private) void |
DefaultTheory.addFact(FolFormula fact)
add facts to knowledge base
|
(package private) void |
DefaultTheory.removeFact(FolFormula fact)
removes fact from knowledge base
|
Modifier and Type | Field and Description |
---|---|
(package private) java.util.Collection<java.util.Collection<FolFormula>> |
DefaultProcessTree.extensions
all extensions of the process tree
|
private java.util.Set<FolFormula> |
DefaultSequence.out
the out set
|
Modifier and Type | Method and Description |
---|---|
java.util.Collection<java.util.Collection<FolFormula>> |
DefaultProcessTree.getExtensions() |
java.util.Collection<FolFormula> |
DefaultSequence.getIn() |
java.util.Collection<FolFormula> |
DefaultSequence.getOut() |
Modifier and Type | Field and Description |
---|---|
private FolFormula |
DefaultRule.conc
The conclusion of the default rule
|
private FolFormula |
DefaultRule.pre
The prerequisite of the default rule
|
Modifier and Type | Field and Description |
---|---|
private java.util.Collection<FolFormula> |
DefaultRule.jus
The justifications of the default rule
|
Modifier and Type | Method and Description |
---|---|
FolFormula |
DefaultRule.getConclusion() |
FolFormula |
DefaultRule.getPrerequisite() |
Modifier and Type | Method and Description |
---|---|
java.util.Collection<FolFormula> |
DefaultRule.getJustification() |
Constructor and Description |
---|
DefaultRule(FolFormula pre,
java.util.Collection<FolFormula> jus,
FolFormula conc) |
DefaultRule(FolFormula pre,
FolFormula jus,
FolFormula conc) |
Constructor and Description |
---|
DefaultRule(FolFormula pre,
java.util.Collection<FolFormula> jus,
FolFormula conc) |
Modifier and Type | Field and Description |
---|---|
private java.util.Map<FolFormula,java.lang.Integer> |
ReferenceWorld.multiplicators
Multiplicators for formulas; saved for efficiency.
|
Modifier and Type | Method and Description |
---|---|
java.lang.Integer |
ReferenceWorld.getMultiplicator(FolFormula f)
Returns the multiplicator of this reference world for the given formula,
i.e.
|
private java.lang.Integer |
ReferenceWorld.getMultiplicatorForConjunction(FolFormula f)
Returns the multiplicator of this reference world for the given formula
(which is a conjunction of literals or a single literal),
i.e.
|
private java.lang.Integer |
ReferenceWorld.getNumberOfOccurences(FolFormula f,
Predicate p,
java.util.Collection<? extends Constant> constants,
boolean positive)
Determines the number of occurrences of instances of predicate "p" with a constant in "constants".
|
Probability |
CondensedProbabilityDistribution.probability(FolFormula f) |
Modifier and Type | Method and Description |
---|---|
Probability |
RpclProbabilityDistribution.probability(FolFormula f)
Gets the probability of the given closed formula, i.e.
|
protected Term |
AbstractRpclSemantics.probabilityTerm(FolFormula f,
java.util.Map<? extends Interpretation,FloatVariable> worlds2vars)
Constructs the term expressing the probability of the given formula "f"
wrt.
|
Constructor and Description |
---|
RelationalProbabilisticConditional(FolFormula premise,
FolFormula conclusion,
Probability probability)
Creates a new conditional with the given premise, conclusion and probability.
|
RelationalProbabilisticConditional(FolFormula conclusion,
Probability probability)
Creates a new conditional with the given conclusion and probability and
a tautological premise.
|
Modifier and Type | Method and Description |
---|---|
FolFormula |
AspFolTranslator.toFOL(DLPLiteral source) |
Modifier and Type | Method and Description |
---|---|
DLPElement |
AspFolTranslator.toASP(FolFormula source) |
Modifier and Type | Method and Description |
---|---|
private void |
AspNlpTranslator.bodiesFromFormula(FolFormula source,
java.util.List<java.util.List<DLPElement>> bodies)
Helper method: Generates a list of possible bodies for the given FOL-Formula.
|
Modifier and Type | Method and Description |
---|---|
FolFormula |
FOLPropTranslator.toFOL(PropositionalFormula propFormula) |
Modifier and Type | Method and Description |
---|---|
PropositionalFormula |
FOLPropTranslator.toPropositional(FolFormula folFormula) |
Modifier and Type | Class and Description |
---|---|
class |
NLPNot
A default negation of a first order formula, nested logic programs
only allow not quantified formulas.
|
Modifier and Type | Field and Description |
---|---|
(package private) FolFormula |
NLPRule.conclusion |
private FolFormula |
NLPNot.inner |
Modifier and Type | Field and Description |
---|---|
(package private) java.util.Set<FolFormula> |
NLPRule.premise |
Modifier and Type | Method and Description |
---|---|
FolFormula |
NLPRule.getConclusion() |
FolFormula |
NLPNot.toNnf() |
Modifier and Type | Method and Description |
---|---|
java.util.Set<FolFormula> |
NLPProgram.getFacts() |
java.util.Collection<FolFormula> |
NLPRule.getPremise() |
Modifier and Type | Method and Description |
---|---|
void |
NLPProgram.addFact(FolFormula fact) |
void |
NLPRule.addPremise(FolFormula premise) |
private void |
NLPRule.checkFormula(FolFormula formula)
Helper methods checks if the given FOL formula is supported by the nested logic
program language, that means it checks if it contains quantifiers and if that
is the case it throws a LanguageException
|
void |
NLPRule.setConclusion(FolFormula conclusion) |
Modifier and Type | Method and Description |
---|---|
void |
NLPRule.addPremises(java.util.Collection<? extends FolFormula> premises) |
Constructor and Description |
---|
NLPNot(FolFormula inner)
Ctor: Creates a new default not for nested logic programs by using the
given FOL formula as inner formula.
|
NLPRule(FolFormula conclusion) |
NLPRule(FolFormula conclusion,
java.util.Collection<FolFormula> premise) |
NLPRule(FolFormula conclusion,
FolFormula premise) |
Constructor and Description |
---|
NLPRule(FolFormula conclusion,
java.util.Collection<FolFormula> premise) |