org.mindswap.pellet.tableau.completion

Class CompletionStrategy

java.lang.Object

org.mindswap.pellet.tableau.completion.CompletionStrategy

Direct Known Subclasses:

EmptySRIQStrategy, SROIQStrategy

public abstract class CompletionStrategy
extends Object

A completion strategy specifies how the tableau rules will be applied to an ABox. Depending on the expressivity of the KB, e.g. SHIN, SHON, etc., different (more efficient) strategies may be used. This class is the base for all different implementations and contains strategy independent functions.

Author:

Evren Sirin

Field Summary

Fields

Modifier and Type	Field and Description
protected ABox	abox ABox being completed
protected AllValuesRule	allValuesRule
protected Blocking	blocking Blocking method specific to this completion strategy
protected TableauRule	chooseRule
protected Timer	completionTimer Timer to be used by the complete function.
protected TableauRule	dataCardRule
protected TableauRule	dataSatRule
protected TableauRule	disjunctionRule
protected TableauRule	guessRule
static Logger	log
protected MaxRule	maxRule
protected List<NodeMerge>	mergeList The queue of node pairs that are waiting to be merged
protected TableauRule	minRule
protected TableauRule	nominalRule
protected TableauRule	selfRule
protected TableauRule	someValuesRule
protected List<TableauRule>	tableauRules
protected TBox	tbox TBox associated with the abox
protected Timers	timers Timers of the associated KB
protected TableauRule	unfoldingRule

Constructor Summary

Constructors

Constructor and Description
CompletionStrategy(ABox abox)

Method Summary

Modifier and Type	Method and Description
protected void	addAllRules()
void	addBranch(Branch newBranch)
Edge	addEdge(Individual subj, Role pred, Node obj, DependencySet ds)
void	addType(Node node, aterm.ATermAppl c, DependencySet ds)
protected void	applyFunctionalMaxRule(Literal x, Role r, DependencySet ds)
void	checkTimer()
abstract void	complete(Expressivity expr) apply all the tableau rules to the designated ABox
protected void	configureTableauRules(Expressivity expr)
Individual	createFreshIndividual(Individual parent, DependencySet ds)
ABox	getABox()
Blocking	getBlocking()
Iterator<Individual>	getInitializeIterator() Return individuals to which we need to apply the initialization rules
TBox	getTBox()
protected boolean	implicitNominals()
void	initialize(Expressivity expressivity)
void	mergeAll() Merge all node pairs in the queue.
protected boolean	mergeIndividuals(Individual y, Individual x, DependencySet ds) Merge individual y into x.
protected void	mergeLiterals(Literal y, Literal x, DependencySet ds) Merge literal y into x.
void	mergeTo(Node y, Node z, DependencySet ds) Merge node y into z.
void	restore(Branch br)
protected void	restoreAllValues()
void	restoreLocal(Individual ind, Branch br)
boolean	setDifferent(Node y, Node z, DependencySet ds)
String	toString()
protected void	updateQueueAddEdge(Individual subj, Role pred, Node obj) This method updates the queue in the event that there is an edge added between two nodes.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

log

public static final Logger log

abox

protected ABox abox

ABox being completed

tbox

protected TBox tbox

TBox associated with the abox

blocking

protected Blocking blocking

Blocking method specific to this completion strategy

timers

protected Timers timers

Timers of the associated KB

completionTimer

protected Timer completionTimer

Timer to be used by the complete function. KB's consistency timer depends on this one and this dependency is set in the constructor. Any concrete class that extends CompletionStrategy should check this timer to respect the timeouts defined in the KB.

mergeList

protected List<NodeMerge> mergeList

The queue of node pairs that are waiting to be merged

unfoldingRule

protected TableauRule unfoldingRule

disjunctionRule

protected TableauRule disjunctionRule

allValuesRule

protected AllValuesRule allValuesRule

someValuesRule

protected TableauRule someValuesRule

chooseRule

protected TableauRule chooseRule

minRule

protected TableauRule minRule

maxRule

protected MaxRule maxRule

selfRule

protected TableauRule selfRule

nominalRule

protected TableauRule nominalRule

guessRule

protected TableauRule guessRule

dataSatRule

protected TableauRule dataSatRule

dataCardRule

protected TableauRule dataCardRule

tableauRules

protected List<TableauRule> tableauRules

Constructor Detail

CompletionStrategy

public CompletionStrategy(ABox abox)

Method Detail

getABox

public ABox getABox()

getTBox

public TBox getTBox()

getBlocking

public Blocking getBlocking()

checkTimer

public void checkTimer()

getInitializeIterator

public Iterator<Individual> getInitializeIterator()

Return individuals to which we need to apply the initialization rules

Returns:

configureTableauRules

protected void configureTableauRules(Expressivity expr)

addAllRules

protected void addAllRules()

implicitNominals

protected boolean implicitNominals()

initialize

public void initialize(Expressivity expressivity)

complete

public abstract void complete(Expressivity expr)

apply all the tableau rules to the designated ABox

createFreshIndividual

public Individual createFreshIndividual(Individual parent,
                                        DependencySet ds)

addType

public void addType(Node node,
                    aterm.ATermAppl c,
                    DependencySet ds)

updateQueueAddEdge

protected void updateQueueAddEdge(Individual subj,
                                  Role pred,
                                  Node obj)

This method updates the queue in the event that there is an edge added between two nodes. The individual must be added back onto the MAXLIST

addEdge

public Edge addEdge(Individual subj,
                    Role pred,
                    Node obj,
                    DependencySet ds)

applyFunctionalMaxRule

protected void applyFunctionalMaxRule(Literal x,
                                      Role r,
                                      DependencySet ds)

mergeAll

public void mergeAll()

Merge all node pairs in the queue.

mergeTo

public void mergeTo(Node y,
                    Node z,
                    DependencySet ds)

Merge node y into z. Node y and all its descendants will be pruned from the completion graph.

Parameters:

y - Node being pruned

z - Node that is being merged into

ds - Dependency of this merge operation

mergeIndividuals

protected boolean mergeIndividuals(Individual y,
                                   Individual x,
                                   DependencySet ds)

Merge individual y into x. Individual y and all its descendants will be pruned from the completion graph.

Parameters:

y - Individual being pruned

x - Individual that is being merged into

ds - Dependency of this merge operation

mergeLiterals

protected void mergeLiterals(Literal y,
                             Literal x,
                             DependencySet ds)

Merge literal y into x. Literal y will be pruned from* the completion graph.

Parameters:

y - Literal being pruned

x - Literal that is being merged into

ds - Dependency of this merge operation

setDifferent

public boolean setDifferent(Node y,
                            Node z,
                            DependencySet ds)

restoreLocal

public void restoreLocal(Individual ind,
                         Branch br)

restore

public void restore(Branch br)

addBranch

public void addBranch(Branch newBranch)

toString

public String toString()

Overrides:

toString in class Object

restoreAllValues

protected void restoreAllValues()