uk.ac.manchester.cs.jfact.kernel

Class TBox

java.lang.Object

uk.ac.manchester.cs.jfact.kernel.TBox

All Implemented Interfaces:

Serializable

@PortedFrom(file="dlTBox.h",
            name="TBox")
public class TBox
extends Object
implements Serializable

tbox

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
TBox(DatatypeFactory datatypeFactory, JFactReasonerConfiguration configuration, AtomicBoolean interrupted, org.semanticweb.owlapi.model.OWLDataFactory df)

Method Summary

Modifier and Type	Method and Description
void	absorbAxioms() absorb all axioms
void	addConceptToHeap(Concept pConcept)
int	addDataExprToHeap(DatatypeEntry p)
int	addDataExprToHeap(LiteralEntry p)
int	addDatatypeExpressionToHeap(Datatype<?> p)
boolean	addNonprimitiveDefinition(Concept left, Concept right, DLTree rightOrigin)
void	addSameIndividuals(Individual p, Pair pair)
void	addSubsumeAxiom(Concept c, DLTree d) add axiom CN [= D for concept CN
void	addSubsumeAxiom(DLTree sub, DLTree sup)
void	addSubsumeForDefined(Concept c, DLTree e) add an axiom CN [= E for defined CN (CN=D already in base)
int	and2dag(DLVertex v, DLTree t) fills AND-like vertex V with an AND-like expression T; process result
DLTree	applyAxiomCNToC(DLTree cn, DLTree d)
DLTree	applyAxiomCToCN(DLTree d, DLTree cn)
int	atmost2dag(int n, Role r, int c)
static boolean	axiomToRangeDomain(DLTree sub, DLTree sup)
DlCompletionTree	buildCompletionTree(Concept pConcept) build a completion tree for a concept C (no caching as it breaks the idea of KE).
void	buildDAG() build dag
void	buildSimpleCache() build simple cache
void	calculateStatistic() calculate statistics
void	calculateTSDepth() calculate TS depth for all concepts
boolean	canUseSortedReasoning()
void	checkEarlySynonym(Concept p) checks if C is defined as C=D and set Synonyms accordingly
Concept	checkToldCycle(Concept p)
void	classifyConcepts(List<Concept> collection, boolean curCompletelyDefined, String type)
void	classifyQueryConcept() classify query concept
void	clearFeatures() clear current features
void	clearQueryConcept() delete all query-related stuff
void	clearRelevanceInfo() clear all relevance info
int	concept2dag(Concept p)
int	countSynonyms()
Concept	createQueryConcept(DLTree desc)
void	createTaxonomy(boolean needIndividual)
int	dataAtMost2dag(int n, Role r, int c)
int	dataForall2dag(Role r, int c)
void	determineSorts() determine sorts
void	dumpAllRoles(uk.ac.manchester.cs.jfact.kernel.DumpInterface dump)
void	dumpConcept(uk.ac.manchester.cs.jfact.kernel.DumpInterface dump, Concept p)
void	dumpExpression(uk.ac.manchester.cs.jfact.kernel.DumpInterface dump, int p)
void	dumpRole(uk.ac.manchester.cs.jfact.kernel.DumpInterface dump, Role p)
<T extends Concept> int	fillArrays(java.util.stream.Stream<T> begin)
void	fillsClassificationTag() mark all concepts wrt their classification tag
void	finishLoading() let TBox know that the whole ontology is loaded
int	forall2dag(Role r, int c)
Concept	getAuxConcept(DLTree desc)
Individual	getBlockingInd(Concept c)
Concept	getCI(DLTree name)
Concept	getConcept(org.semanticweb.owlapi.model.IRI name) return registered concept by given NAME;
java.util.stream.Stream<Concept>	getConcepts()
gnu.trove.list.TIntList	getConceptsForQueryAnswering()
DLDag	getDag()
String	getDataEntryByBP(int bp)
List<List<Individual>>	getDifferent()
DLDag	getDLHeap()
RoleMaster	getDRM()
List<Concept>	getFairness()
DLTree	getFreshConcept()
KBFlags	getGCIs()
Individual	getIndividual(org.semanticweb.owlapi.model.IRI name) return registered individual by given NAME;
uk.ac.manchester.cs.jfact.kernel.TBox.IterableVec<Individual>	getIV()
int	getNItems()
int	getnSkipBeforeBlock()
JFactReasonerConfiguration	getOptions()
RoleMaster	getORM()
DlSatTester	getReasoner()
List<Related>	getRelatedI()
RoleMaster	getRM(Role r)
org.semanticweb.owlapitools.decomposition.Signature	getSignature(ClassifiableEntry c)
uk.ac.manchester.cs.jfact.kernel.SimpleRule	getSimpleRule(int index)
Individual	getSPForConcept(Concept p)
InAx	getStatistics()
KBStatus	getStatus()
Taxonomy	getTaxonomy()
int	getTG()
DLTree	getTree(Concept c)
boolean	hasFC()
java.util.stream.Stream<Individual>	individuals()
ModelCacheInterface	initCache(Concept pConcept, boolean sub)
void	initRangeDomain(RoleMaster rm)
void	initReasoner() init reasoner
void	initRuleFields(List<Concept> v, int index) init Extra Rule field in concepts given by a vector V with a given INDEX
void	initTaxonomy() init taxonomy and classifier
void	initToldSubsumers() set told TOP concept whether necessary
boolean	isBlockedInd(Concept c)
boolean	isBlockingDet(Concept c)
AtomicBoolean	isCancelled()
boolean	isConsistent()
boolean	isCyclic(Concept c)
boolean	isDisjointRoles(Role r, Role s)
boolean	isDuringClassification()
boolean	isIndividual(DLTree tree)
boolean	isIRinQuery()
boolean	isIrreflexive(Role r)
boolean	isNRinQuery()
boolean	isSameIndividuals(Individual a, Individual b)
boolean	isSatisfiable(Concept pConcept)
boolean	isSubHolds(Concept pConcept, Concept qConcept)
DLTree	makeNonPrimitive(Concept p, DLTree desc) make concept non-primitive;
void	performClassification() perform classification (assuming KB is consistent)
boolean	performConsistencyCheck()
void	performRealisation() perform realisation (assuming KB is consistent)
void	prepareFeatures(Concept pConcept, Concept qConcept)
void	prepareReasoning() prepare reasoning
void	preprocess() preprocess tbox
void	preprocessQueryConcept(Concept query) preprocess query concept: put description into DAG
void	preprocessRelated() preprocess related individuals
void	print() print TBox as a whole
void	printAxioms(LogAdapter o)
void	printConcept(LogAdapter o, Concept p)
void	printConcepts(LogAdapter o) print all registered concepts
void	printDagEntry(LogAdapter o, int p)
void	printFeatures() print features
void	printIndividuals(LogAdapter o) print all registered individuals
void	printSimpleRules(LogAdapter o)
void	processDifferent(List<DLTree> l)
void	processDisjoint(List<DLTree> beg) process a disjoint set [beg,end) in a usual manner
void	processDisjointC(Collection<DLTree> beg)
void	processDisjointR(List<DLTree> l)
void	processEquivalentC(List<DLTree> l)
void	processEquivalentR(List<DLTree> l)
void	processGCI(DLTree c, DLTree d) try to absorb GCI C[=D; if not possible, just record this GCI
void	processSame(List<DLTree> l)
void	reclassify(Set<org.semanticweb.owlapi.model.OWLEntity> mPlus, Set<org.semanticweb.owlapi.model.OWLEntity> mMinus)
int	reflexive2dag(Role r)
void	registerIndividualRelation(NamedEntry a, NamedEntry r, NamedEntry b) individual relation (a,b):R
void	removeExtraDescriptions() remove extra descritpions
Concept	replaceForall(DLTree rc) replace (AR:C) with X such that C [= AR^-:X for fresh X.
void	setConceptIndex(Concept c) set new concept index for given C wrt existing nC
void	setConsistency(boolean val) set consistency flag
void	setFairnessConstraintDLTrees(List<DLTree> l)
boolean	setForbidUndefinedNames(boolean val) set the flag that forbid usage of undefined names for concepts/roles;
void	setNameSigMap(Map<org.semanticweb.owlapi.model.OWLEntity,org.semanticweb.owlapitools.decomposition.Signature> p) set NameSigMap
void	setToDoPriorities() set To Do priorities using local OPTIONS
void	setToldTop() set told TOP concept whether necessary
boolean	switchToNonprimitive(DLTree left, DLTree right)
ModelCacheState	testCachedNonSubsumption(Concept p, Concept q) test if 2 concept non-subsumption can be determined by cache merging
boolean	testHasNominals()
boolean	testHasTopRole()
boolean	testSortedNonSubsumption(Concept p, Concept q)
void	transformSingletonHierarchy() transform singleton hierarchy
void	transformToldCycles() transform cycles
int	tree2dag(DLTree t)
void	writeReasoningResult(long time)

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

TBox

public TBox(DatatypeFactory datatypeFactory,
            JFactReasonerConfiguration configuration,
            AtomicBoolean interrupted,
            org.semanticweb.owlapi.model.OWLDataFactory df)

Parameters:

datatypeFactory - datatypeFactory

configuration - configuration

interrupted - interrupted

df - data factory

Method Detail

getStatistics

public InAx getStatistics()

Returns:

statistics

individuals

@PortedFrom(file="dlTBox.h",
            name="i_begin")
public java.util.stream.Stream<Individual> individuals()

Returns:

individuals

getConcepts

@PortedFrom(file="dlTBox.h",
            name="c_begin")
public java.util.stream.Stream<Concept> getConcepts()

Returns:

list of concepts

getOptions

@Original
public JFactReasonerConfiguration getOptions()

Returns:

reasoner configuration

getDataEntryByBP

@PortedFrom(file="dlTBox.h",
            name="getDataEntryByBP")
public String getDataEntryByBP(int bp)

Parameters:

bp - bp

Returns:

concept by it's BP (non- version)

makeNonPrimitive

@PortedFrom(file="dlTBox.h",
            name="makeNonPrimitive")
public DLTree makeNonPrimitive(Concept p,
                                                                                                 DLTree desc)

make concept non-primitive;

Parameters:

p - p

desc - desc

Returns:

it's old description

checkEarlySynonym

@PortedFrom(file="dlTBox.h",
            name="checkEarlySynonym")
public void checkEarlySynonym(Concept p)

checks if C is defined as C=D and set Synonyms accordingly

Parameters:

p - p

processDisjoint

@PortedFrom(file="dlTBox.h",
            name="processDisjoint")
public void processDisjoint(List<DLTree> beg)

process a disjoint set [beg,end) in a usual manner

Parameters:

beg - beg

reflexive2dag

@PortedFrom(file="dlTBox.h",
            name="reflexive2dag")
public int reflexive2dag(Role r)

Parameters:

r - R

Returns:

create REFLEXIVE node

dataForall2dag

@PortedFrom(file="dlTBox.h",
            name="dataForall2dag")
public int dataForall2dag(Role r,
                                                                                          int c)

Parameters:

r - R

c - C

Returns:

create forall node for data role

dataAtMost2dag

@PortedFrom(file="dlTBox.h",
            name="dataAtMost2dag")
public int dataAtMost2dag(int n,
                                                                                          Role r,
                                                                                          int c)

Parameters:

n - n

r - R

c - C

Returns:

create atmost node for data role

concept2dag

@PortedFrom(file="dlTBox.h",
            name="concept2dag")
public int concept2dag(@Nullable
                                                                                    Concept p)

Parameters:

p - p

Returns:

a pointer to concept representation

processGCI

@PortedFrom(file="dlTBox.h",
            name="processGCI")
public void processGCI(DLTree c,
                                                                                   DLTree d)

try to absorb GCI C[=D; if not possible, just record this GCI

Parameters:

c - C

d - D

absorbAxioms

@PortedFrom(file="dlTBox.h",
            name="AbsorbAxioms")
public void absorbAxioms()

absorb all axioms

initToldSubsumers

@PortedFrom(file="dlTBox.h",
            name="initToldSubsumers")
public void initToldSubsumers()

set told TOP concept whether necessary

setToldTop

@PortedFrom(file="dlTBox.h",
            name="setToldTop")
public void setToldTop()

set told TOP concept whether necessary

calculateTSDepth

@PortedFrom(file="dlTBox.h",
            name="calculateTSDepth")
public void calculateTSDepth()

calculate TS depth for all concepts

countSynonyms

@PortedFrom(file="dlTBox.h",
            name="countSynonyms")
public int countSynonyms()

Returns:

number of synonyms in the KB

initRuleFields

@PortedFrom(file="dlTBox.h",
            name="initRuleFields")
public void initRuleFields(List<Concept> v,
                                                                                           int index)

init Extra Rule field in concepts given by a vector V with a given INDEX

Parameters:

v - v

index - index

fillsClassificationTag

@PortedFrom(file="dlTBox.h",
            name="fillsClassificationTag")
public void fillsClassificationTag()

mark all concepts wrt their classification tag

setConceptIndex

@PortedFrom(file="dlTBox.h",
            name="setConceptIndex")
public void setConceptIndex(Concept c)

set new concept index for given C wrt existing nC

Parameters:

c - C

getReasoner

@PortedFrom(file="dlTBox.h",
            name="getReasoner")
public DlSatTester getReasoner()

Returns:

reasoner wrt nominal case

printConcepts

@PortedFrom(file="dlTBox.h",
            name="PrintConcepts")
public void printConcepts(LogAdapter o)

print all registered concepts

Parameters:

o - o

printIndividuals

@PortedFrom(file="dlTBox.h",
            name="PrintIndividuals")
public void printIndividuals(LogAdapter o)

print all registered individuals

Parameters:

o - o

printSimpleRules

@PortedFrom(file="dlTBox.h",
            name="PrintSimpleRules")
public void printSimpleRules(LogAdapter o)

Parameters:

o - o

printAxioms

@PortedFrom(file="dlTBox.h",
            name="PrintAxioms")
public void printAxioms(LogAdapter o)

Parameters:

o - o

isIrreflexive

@PortedFrom(file="dlTBox.h",
            name="isIrreflexive")
public boolean isIrreflexive(Role r)

Parameters:

r - R

Returns:

check if the role R is irreflexive

clearRelevanceInfo

@PortedFrom(file="dlTBox.h",
            name="clearRelevanceInfo")
public void clearRelevanceInfo()

clear all relevance info

getFreshConcept

@PortedFrom(file="dlTBox.h",
            name="getFreshConcept")
public DLTree getFreshConcept()

Returns:

fresh concept

clearFeatures

@PortedFrom(file="dlTBox.h",
            name="clearFeatures")
public void clearFeatures()

clear current features

getORM

@PortedFrom(file="dlTBox.h",
            name="getORM")
public RoleMaster getORM()

Returns:

object Role Master

getDRM

@PortedFrom(file="dlTBox.h",
            name="getDRM")
public RoleMaster getDRM()

Returns:

Data Role Master

getRM

@PortedFrom(file="dlTBox.h",
            name="getRM")
public RoleMaster getRM(Role r)

Parameters:

r - R

Returns:

RoleMaster depending of the R

getDag

@PortedFrom(file="dlTBox.h",
            name="getDag")
public DLDag getDag()

Returns:

DAG (needed for KE)

getConcept

@PortedFrom(file="dlTBox.h",
            name="getConcept")
public Concept getConcept(org.semanticweb.owlapi.model.IRI name)

return registered concept by given NAME;

Parameters:

name - name

Returns:

null if can't register

getIndividual

@PortedFrom(file="dlTBox.h",
            name="getIndividual")
public Individual getIndividual(org.semanticweb.owlapi.model.IRI name)

return registered individual by given NAME;

Parameters:

name - name

Returns:

null if can't register

isIndividual

@PortedFrom(file="dlTBox.h",
            name="isIndividual")
public boolean isIndividual(DLTree tree)

Parameters:

tree - tree

Returns:

true iff given TREE represents a registered individual

getCI

@Nullable
 @PortedFrom(file="dlTBox.h",
            name="getCI")
public Concept getCI(DLTree name)

Parameters:

name - name

Returns:

TOP/BOTTOM/CN/IN by the DLTree entry

getTree

@Nullable
 @PortedFrom(file="dlTBox.h",
            name="getTree")
public DLTree getTree(@Nullable
                                                                                          Concept c)

Parameters:

c - C

Returns:

a DL tree by a given concept-like C

setForbidUndefinedNames

@PortedFrom(file="dlTBox.h",
            name="setForbidUndefinedNames")
public boolean setForbidUndefinedNames(boolean val)

set the flag that forbid usage of undefined names for concepts/roles;

Parameters:

val - val

Returns:

old value

registerIndividualRelation

@PortedFrom(file="dlTBox.h",
            name="RegisterIndividualRelation")
public void registerIndividualRelation(NamedEntry a,
                                                                                                                   NamedEntry r,
                                                                                                                   NamedEntry b)

individual relation (a,b):R

Parameters:

a - a

r - R

b - b

addSubsumeAxiom

@PortedFrom(file="dlTBox.h",
            name="addSubsumeAxiom")
public void addSubsumeAxiom(Concept c,
                                                                                             DLTree d)

add axiom CN [= D for concept CN

Parameters:

c - C

d - D

finishLoading

@PortedFrom(file="dlTBox.h",
            name="finishLoading")
public void finishLoading()

let TBox know that the whole ontology is loaded

hasFC

@PortedFrom(file="dlTBox.h",
            name="hasFC")
public boolean hasFC()

Returns:

true if KB contains fairness constraints

setFairnessConstraintDLTrees

@PortedFrom(file="dlTBox.h",
            name="setFairnessConstraint")
public void setFairnessConstraintDLTrees(List<DLTree> l)

Parameters:

l - l

getTG

@PortedFrom(file="dlTBox.h",
            name="getTG")
public int getTG()

Returns:

GCI Axioms

getSimpleRule

@PortedFrom(file="dlTBox.h",
            name="getSimpleRule")
public uk.ac.manchester.cs.jfact.kernel.SimpleRule getSimpleRule(int index)

Parameters:

index - index

Returns:

simple rule by its INDEX

isIRinQuery

@PortedFrom(file="dlTBox.h",
            name="isIRinQuery")
public boolean isIRinQuery()

Returns:

check if the relevant part of KB contains inverse roles.

isNRinQuery

@PortedFrom(file="dlTBox.h",
            name="isNRinQuery")
public boolean isNRinQuery()

Returns:

check if the relevant part of KB contains number restrictions.

testHasNominals

@PortedFrom(file="dlTBox.h",
            name="testHasNominals")
public boolean testHasNominals()

Returns:

check if the relevant part of KB contains singletons

testHasTopRole

@PortedFrom(file="dlTBox.h",
            name="testHasTopRole")
public boolean testHasTopRole()

Returns:

check if the relevant part of KB contains top role

canUseSortedReasoning

@PortedFrom(file="dlTBox.h",
            name="canUseSortedReasoning")
public boolean canUseSortedReasoning()

Returns:

check if Sorted Reasoning is applicable

performClassification

@PortedFrom(file="dlTBox.h",
            name="performClassification")
public void performClassification()

perform classification (assuming KB is consistent)

performRealisation

@PortedFrom(file="dlTBox.h",
            name="performRealisation")
public void performRealisation()

perform realisation (assuming KB is consistent)

getTaxonomy

@PortedFrom(file="dlTBox.h",
            name="getTaxonomy")
public Taxonomy getTaxonomy()

Returns:

internal Taxonomy of concepts

getStatus

@PortedFrom(file="dlTBox.h",
            name="getStatus")
public KBStatus getStatus()

Returns:

status flag

setConsistency

@PortedFrom(file="dlTBox.h",
            name="setConsistency")
public void setConsistency(boolean val)

set consistency flag

Parameters:

val - val

isConsistent

@PortedFrom(file="dlTBox.h",
            name="isConsistent")
public boolean isConsistent()

Returns:

check if the ontology is consistent

testSortedNonSubsumption

@PortedFrom(file="dlTBox.h",
            name="testSortedNonSubsumption")
public boolean testSortedNonSubsumption(Concept p,
                                                                                                                  @Nullable
                                                                                                                  Concept q)

Parameters:

p - p

q - q

Returns:

test if 2 concept non-subsumption can be determined by sorts checking

print

@PortedFrom(file="dlTBox.h",
            name="print")
public void print()

print TBox as a whole

buildDAG

@PortedFrom(file="dlTBox.h",
            name="buildDAG")
public void buildDAG()

build dag

initRangeDomain

@PortedFrom(file="dlTBox.h",
            name="initRangeDomain")
public void initRangeDomain(RoleMaster rm)

Parameters:

rm - RM

addDataExprToHeap

@PortedFrom(file="dlTBox.h",
            name="addDataExprToHeap")
public int addDataExprToHeap(LiteralEntry p)

Parameters:

p - p

Returns:

index of new element

addDataExprToHeap

@PortedFrom(file="dlTBox.h",
            name="addDataExprToHeap")
public int addDataExprToHeap(DatatypeEntry p)

Parameters:

p - p

Returns:

index of new element

addDatatypeExpressionToHeap

@Original
public int addDatatypeExpressionToHeap(Datatype<?> p)

Parameters:

p - p

Returns:

index of new element

addConceptToHeap

@PortedFrom(file="dlTBox.h",
            name="addConceptToHeap")
public void addConceptToHeap(Concept pConcept)

Parameters:

pConcept - pConcept

tree2dag

@PortedFrom(file="dlTBox.h",
            name="tree2dag")
public int tree2dag(@Nullable
                                                                              DLTree t)

Parameters:

t - t

Returns:

index of new element

and2dag

@PortedFrom(file="dlTBox.h",
            name="and2dag")
public int and2dag(DLVertex v,
                                                                            DLTree t)

fills AND-like vertex V with an AND-like expression T; process result

Parameters:

v - v

t - t

Returns:

heap size

forall2dag

@PortedFrom(file="dlTBox.h",
            name="forall2dag")
public int forall2dag(Role r,
                                                                                  int c)

Parameters:

r - R

c - C

Returns:

index of new element

atmost2dag

@PortedFrom(file="dlTBox.h",
            name="atmost2dag")
public int atmost2dag(int n,
                                                                                  Role r,
                                                                                  int c)

Parameters:

n - n

r - R

c - C

Returns:

index of new element

fillArrays

@PortedFrom(file="dlTBox.h",
            name="fillArrays")
public <T extends Concept> int fillArrays(java.util.stream.Stream<T> begin)

Type Parameters:

T - concept type

Parameters:

begin - begin

Returns:

number of elements

getNItems

@Original
public int getNItems()

Returns:

n items

createTaxonomy

@PortedFrom(file="dlTBox.h",
            name="createTaxonomy")
public void createTaxonomy(boolean needIndividual)

Parameters:

needIndividual - needIndividual

classifyConcepts

@PortedFrom(file="dlTBox.h",
            name="classifyConcepts")
public void classifyConcepts(List<Concept> collection,
                                                                                               boolean curCompletelyDefined,
                                                                                               String type)

Parameters:

collection - collection

curCompletelyDefined - curCompletelyDefined

type - type

getAuxConcept

@PortedFrom(file="dlTBox.h",
            name="getAuxConcept")
public Concept getAuxConcept(@Nullable
                                                                                            DLTree desc)

Parameters:

desc - desc

Returns:

concept for desc

prepareReasoning

@PortedFrom(file="dlTBox.h",
            name="prepareReasoning")
public void prepareReasoning()

prepare reasoning

prepareFeatures

@PortedFrom(file="dlTBox.h",
            name="prepareFeatures")
public void prepareFeatures(@Nullable
                                                                                             Concept pConcept,
                                                                                             @Nullable
                                                                                             Concept qConcept)

Parameters:

pConcept - pConcept

qConcept - qConcept

buildSimpleCache

@PortedFrom(file="dlTBox.h",
            name="buildSimpleCache")
public void buildSimpleCache()

build simple cache

performConsistencyCheck

@PortedFrom(file="dlTBox.h",
            name="performConsistencyCheck")
public boolean performConsistencyCheck()

Returns:

true if consistent

isSatisfiable

@PortedFrom(file="dlTBox.h",
            name="isSatisfiable")
public boolean isSatisfiable(Concept pConcept)

Parameters:

pConcept - pConcept

Returns:

true if satisfiable

isSubHolds

@PortedFrom(file="dlTBox.h",
            name="isSubHolds")
public boolean isSubHolds(Concept pConcept,
                                                                                      Concept qConcept)

Parameters:

pConcept - pConcept

qConcept - qConcept

Returns:

true if subsumption holds

isSameIndividuals

@PortedFrom(file="dlTBox.h",
            name="isSameIndividuals")
public boolean isSameIndividuals(Individual a,
                                                                                                    Individual b)

Parameters:

a - _a

b - _b

Returns:

true if same individual

isDisjointRoles

@PortedFrom(file="dlTBox.h",
            name="isDisjointRoles")
public boolean isDisjointRoles(Role r,
                                                                                                Role s)

Parameters:

r - R

s - S

Returns:

true if disjoint roles

createQueryConcept

@PortedFrom(file="dlTBox.h",
            name="createQueryConcept")
public Concept createQueryConcept(DLTree desc)

Parameters:

desc - desc

Returns:

query concept

preprocessQueryConcept

@PortedFrom(file="dlTBox.h",
            name="preprocessQueryConcept")
public void preprocessQueryConcept(Concept query)

preprocess query concept: put description into DAG

Parameters:

query - query

clearQueryConcept

@PortedFrom(file="dlTBox.h",
            name="clearQueryConcept")
public void clearQueryConcept()

delete all query-related stuff

classifyQueryConcept

@PortedFrom(file="dlTBox.h",
            name="classifyQueryConcept")
public void classifyQueryConcept()

classify query concept

buildCompletionTree

@PortedFrom(file="dlTBox.h",
            name="buildCompletionTree")
public DlCompletionTree buildCompletionTree(Concept pConcept)

build a completion tree for a concept C (no caching as it breaks the idea of KE).

Parameters:

pConcept - pConcept

Returns:

the root node

writeReasoningResult

@PortedFrom(file="dlTBox.h",
            name="writeReasoningResult")
public void writeReasoningResult(long time)

Parameters:

time - time

printDagEntry

@PortedFrom(file="dlTBox.h",
            name="PrintDagEntry")
public void printDagEntry(LogAdapter o,
                                                                                         int p)

Parameters:

o - o

p - p

printConcept

@PortedFrom(file="dlTBox.h",
            name="PrintConcept")
public void printConcept(LogAdapter o,
                                                                                       Concept p)

Parameters:

o - o

p - p

dumpConcept

@PortedFrom(file="dlTBox.h",
            name="dumpConcept")
public void dumpConcept(uk.ac.manchester.cs.jfact.kernel.DumpInterface dump,
                                                                                     Concept p)

Parameters:

dump - dump

p - p

dumpRole

@PortedFrom(file="dlTBox.h",
            name="dumpRole")
public void dumpRole(uk.ac.manchester.cs.jfact.kernel.DumpInterface dump,
                                                                               Role p)

Parameters:

dump - dump

p - p

dumpExpression

@PortedFrom(file="dlTBox.h",
            name="dumpExpression")
public void dumpExpression(uk.ac.manchester.cs.jfact.kernel.DumpInterface dump,
                                                                                           int p)

Parameters:

dump - dump

p - p

dumpAllRoles

@PortedFrom(file="dlTBox.h",
            name="dumpAllRoles")
public void dumpAllRoles(uk.ac.manchester.cs.jfact.kernel.DumpInterface dump)

Parameters:

dump - dump

addSubsumeAxiom

@PortedFrom(file="dlTBox.h",
            name="addSubsumeAxiom")
public void addSubsumeAxiom(@Nullable
                                                                                             DLTree sub,
                                                                                             @Nullable
                                                                                             DLTree sup)

Parameters:

sub - sub

sup - sup

applyAxiomCToCN

@Nullable
 @PortedFrom(file="dlTBox.h",
            name="applyAxiomCToCN")
public DLTree applyAxiomCToCN(DLTree d,
                                                                                                          DLTree cn)

Parameters:

d - D

cn - CN

Returns:

merged dltree

applyAxiomCNToC

@Nullable
 @PortedFrom(file="dlTBox.h",
            name="applyAxiomCNToC")
public DLTree applyAxiomCNToC(DLTree cn,
                                                                                                          DLTree d)

Parameters:

cn - CN

d - D

Returns:

merged dltree

addSubsumeForDefined

@PortedFrom(file="dlTBox.h",
            name="addSubsumeForDefined")
public void addSubsumeForDefined(Concept c,
                                                                                                       DLTree e)

add an axiom CN [= E for defined CN (CN=D already in base)

Parameters:

c - C

e - superclass

axiomToRangeDomain

@PortedFrom(file="dlTBox.h",
            name="axiomToRangeDomain")
public static boolean axiomToRangeDomain(DLTree sub,
                                                                                                             DLTree sup)

Parameters:

sub - sub

sup - sup

Returns:

true if range can be set

addNonprimitiveDefinition

@PortedFrom(file="dlTBox.h",
            name="addNonprimitiveDefinition")
public boolean addNonprimitiveDefinition(Concept left,
                                                                                                                    @Nullable
                                                                                                                    Concept right,
                                                                                                                    DLTree rightOrigin)

Parameters:

left - left

right - right

rightOrigin - original right tree

Returns:

true if definition is added

switchToNonprimitive

@PortedFrom(file="dlTBox.h",
            name="switchToNonprimitive")
public boolean switchToNonprimitive(DLTree left,
                                                                                                          DLTree right)

Parameters:

left - left

right - right

Returns:

true if concept is made non primitive

processDisjointC

@PortedFrom(file="dlTBox.h",
            name="processDisjointC")
public void processDisjointC(Collection<DLTree> beg)

Parameters:

beg - beg

processEquivalentC

@PortedFrom(file="dlTBox.h",
            name="processEquivalentC")
public void processEquivalentC(List<DLTree> l)

Parameters:

l - argument list

processDifferent

@PortedFrom(file="dlTBox.h",
            name="processDifferent")
public void processDifferent(List<DLTree> l)

Parameters:

l - l

processSame

@PortedFrom(file="dlTBox.h",
            name="processSame")
public void processSame(List<DLTree> l)

Parameters:

l - l

processDisjointR

@PortedFrom(file="dlTBox.h",
            name="processDisjointR")
public void processDisjointR(List<DLTree> l)

Parameters:

l - l

processEquivalentR

@PortedFrom(file="dlTBox.h",
            name="processEquivalentR")
public void processEquivalentR(List<DLTree> l)

Parameters:

l - l

preprocess

@PortedFrom(file="dlTBox.h",
            name="preprocess")
public void preprocess()

preprocess tbox

isCyclic

@PortedFrom(file="Preprocess.cpp",
            name="isCyclic")
public boolean isCyclic(Concept c)

Parameters:

c - concept

Returns:

true iff C has a cyclic definition, ie is referenced in its own description

preprocessRelated

@PortedFrom(file="dlTBox.h",
            name="preprocessRelated")
public void preprocessRelated()

preprocess related individuals

transformToldCycles

@PortedFrom(file="dlTBox.h",
            name="transformToldCycles")
public void transformToldCycles()

transform cycles

checkToldCycle

@Nullable
 @PortedFrom(file="dlTBox.h",
            name="checkToldCycle")
public Concept checkToldCycle(Concept p)

Parameters:

p - _p

Returns:

concpet with told cycle rewritten

transformSingletonHierarchy

@PortedFrom(file="dlTBox.h",
            name="transformSingletonHierarchy")
public void transformSingletonHierarchy()

transform singleton hierarchy

getSPForConcept

@PortedFrom(file="dlTBox.h",
            name="getSPForConcept")
public Individual getSPForConcept(Concept p)

Parameters:

p - p

Returns:

individual for concept

determineSorts

@PortedFrom(file="dlTBox.h",
            name="determineSorts")
public void determineSorts()

determine sorts

calculateStatistic

@PortedFrom(file="dlTBox.h",
            name="CalculateStatistic")
public void calculateStatistic()

calculate statistics

removeExtraDescriptions

@PortedFrom(file="dlTBox.h",
            name="RemoveExtraDescriptions")
public void removeExtraDescriptions()

remove extra descritpions

setToDoPriorities

@Original
public void setToDoPriorities()

set To Do priorities using local OPTIONS

isBlockedInd

@PortedFrom(file="dlTBox.h",
            name="isBlockedInd")
public boolean isBlockedInd(Concept c)

Parameters:

c - C

Returns:

true iff individual C is known to be p-blocked by another one

getBlockingInd

@PortedFrom(file="dlTBox.h",
            name="getBlockingInd")
public Individual getBlockingInd(Concept c)

Parameters:

c - C

Returns:

individual that blocks C; works only for blocked individuals C

isBlockingDet

@PortedFrom(file="dlTBox.h",
            name="isBlockingDet")
public boolean isBlockingDet(Concept c)

Parameters:

c - C

Returns:

true iff an individual blocks C deterministically

initCache

@PortedFrom(file="dlTBox.h",
            name="initCache")
public ModelCacheInterface initCache(Concept pConcept,
                                                                                                boolean sub)

Parameters:

pConcept - pConcept

sub - sub

Returns:

initialized cache

testCachedNonSubsumption

@PortedFrom(file="dlTBox.h",
            name="testCachedNonSubsumption")
public ModelCacheState testCachedNonSubsumption(Concept p,
                                                                                                                          Concept q)

test if 2 concept non-subsumption can be determined by cache merging

Parameters:

p - p

q - q

Returns:

cache state

initReasoner

@PortedFrom(file="dlTBox.h",
            name="initReasoner")
public void initReasoner()

init reasoner

initTaxonomy

@PortedFrom(file="DLConceptTaxonomy.h",
            name="initTaxonomy")
public void initTaxonomy()

init taxonomy and classifier

setNameSigMap

@PortedFrom(file="dlTBox.h",
            name="setNameSigMap")
public void setNameSigMap(Map<org.semanticweb.owlapi.model.OWLEntity,org.semanticweb.owlapitools.decomposition.Signature> p)

set NameSigMap

Parameters:

p - p

getSignature

@Nullable
 @Original
public org.semanticweb.owlapitools.decomposition.Signature getSignature(ClassifiableEntry c)

Parameters:

c - c

Returns:

signature

printFeatures

@PortedFrom(file="dlTBox.h",
            name="printFeatures")
public void printFeatures()

print features

getDifferent

@Original
public List<List<Individual>> getDifferent()

Returns:

list of list of different individuals

getRelatedI

@Original
public List<Related> getRelatedI()

Returns:

list of relted individuals

getDLHeap

@Original
public DLDag getDLHeap()

Returns:

the dl heap

getGCIs

@Original
public KBFlags getGCIs()

Returns:

the GCIs

replaceForall

@PortedFrom(file="dlTBox.h",
            name="replaceForall")
public Concept replaceForall(DLTree rc)

replace (AR:C) with X such that C [= AR^-:X for fresh X.

Parameters:

rc - RC

Returns:

X

isCancelled

@PortedFrom(file="dlTBox.h",
            name="isCancelled")
public AtomicBoolean isCancelled()

Returns:

interrupted switch

getFairness

@Original
public List<Concept> getFairness()

Returns:

list of fairness concepts

addSameIndividuals

public void addSameIndividuals(Individual p,
                               Pair pair)

Parameters:

p - p

pair - pair

reclassify

public void reclassify(Set<org.semanticweb.owlapi.model.OWLEntity> mPlus,
                       Set<org.semanticweb.owlapi.model.OWLEntity> mMinus)

Parameters:

mPlus - MPlus

mMinus - MMinus

getConceptsForQueryAnswering

public gnu.trove.list.TIntList getConceptsForQueryAnswering()

Returns:

list of concept index

isDuringClassification

public boolean isDuringClassification()

Returns:

true if in classification

getIV

public uk.ac.manchester.cs.jfact.kernel.TBox.IterableVec<Individual> getIV()

Returns:

individuals

getnSkipBeforeBlock

public int getnSkipBeforeBlock()

Returns:

skip before block