ai.grakn.graql.internal.reasoner.rule

Class InferenceRule

java.lang.Object

ai.grakn.graql.internal.reasoner.rule.InferenceRule

public class InferenceRule
extends Object

Class providing resolution and higher level facilities for Rule objects.

Author:

Kasper Piskorski

Constructor Summary

Constructors

Constructor and Description
InferenceRule(Rule rule, GraknTx tx)

Method Summary

Modifier and Type	Method and Description
boolean	equals(Object obj)
ReasonerQueryImpl	getBody()
ReasonerAtomicQuery	getHead()
MultiUnifier	getMultiUnifier(Atom parentAtom)
Atom	getRuleConclusionAtom()
ConceptId	getRuleId()
boolean	hasDisconnectedHead()
int	hashCode()
InferenceRule	propagateConstraints(Atom parentAtom, Unifier unifier)
boolean	requiresMaterialisation(Atom parentAtom) rule requires materialisation in the context of resolving parent atom if parent atom requires materialisation, head atom requires materialisation or if the head contains only fresh variables
int	resolutionPriority()
InferenceRule	rewrite(Atom parentAtom) rewrite the rule to a form with user defined variables
ResolutionState	subGoal(Atom parentAtom, Unifier ruleUnifier, QueryStateBase parent, Set<ReasonerAtomicQuery> visitedSubGoals, QueryCache<ReasonerAtomicQuery> cache)
String	toString()
InferenceRule	withSubstitution(Answer sub)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

InferenceRule

public InferenceRule(Rule rule,
                     GraknTx tx)

Method Detail

toString

public String toString()

Overrides:

toString in class Object

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

resolutionPriority

public int resolutionPriority()

Returns:

the priority with which the rule should be fired

getRuleId

public ConceptId getRuleId()

hasDisconnectedHead

public boolean hasDisconnectedHead()

Returns:

true if the rule has disconnected head, i.e. head and body do not share any variables

requiresMaterialisation

public boolean requiresMaterialisation(Atom parentAtom)

rule requires materialisation in the context of resolving parent atom if parent atom requires materialisation, head atom requires materialisation or if the head contains only fresh variables

Returns:

true if the rule needs to be materialised

getBody

public ReasonerQueryImpl getBody()

Returns:

body of the rule of the form head :- body

getHead

public ReasonerAtomicQuery getHead()

Returns:

head of the rule of the form head :- body

withSubstitution

public InferenceRule withSubstitution(Answer sub)

Parameters:

sub - substitution to be added to the rule

Returns:

inference rule with added substitution

getRuleConclusionAtom

public Atom getRuleConclusionAtom()

Returns:

a conclusion atom which parent contains all atoms in the rule

propagateConstraints

public InferenceRule propagateConstraints(Atom parentAtom,
                                          Unifier unifier)

Parameters:

parentAtom - atom containing constraints (parent)

unifier - unifier unifying parent with the rule

Returns:

rule with propagated constraints from parent

rewrite

public InferenceRule rewrite(Atom parentAtom)

rewrite the rule to a form with user defined variables

Parameters:

parentAtom - reference parent atom

Returns:

rewritten rule

subGoal

public ResolutionState subGoal(Atom parentAtom,
                               Unifier ruleUnifier,
                               QueryStateBase parent,
                               Set<ReasonerAtomicQuery> visitedSubGoals,
                               QueryCache<ReasonerAtomicQuery> cache)

Parameters:

parentAtom - atom to which this rule is applied

ruleUnifier - unifier with parent state

parent - parent state

visitedSubGoals - set of visited sub goals

cache - query cache

Returns:

resolution subGoal formed from this rule

getMultiUnifier

public MultiUnifier getMultiUnifier(Atom parentAtom)

Parameters:

parentAtom - atom to unify the rule with

Returns:

corresponding unifier