uk.ac.manchester.cs.jfact.kernel

Class TBox

java.lang.Object

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

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

Field Summary

Fields

Modifier and Type	Field and Description
protected int	nC number of concepts and individuals; used to set index for modelCache
protected int	nR number of all distinct roles; used to set index for modelCache

Constructor Summary

Constructors

Constructor and Description
TBox(DatatypeFactory datatypeFactory, JFactReasonerConfiguration configuration, String topObjectRoleName, String botObjectRoleName, String topDataRoleName, String botDataRoleName, AtomicBoolean interrupted)

Method Summary

Methods

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(DLTree left, DLTree right)
void	addSimpleRule(uk.ac.manchester.cs.jfact.kernel.SimpleRule Rule) add simple rule RULE to the TBox' rules
void	addSubsumeAxiom(Concept C, DLTree D) add axiom CN [= D for concept CN
void	addSubsumeAxiom(DLTree sub, DLTree sup)
void	addSubsumeForDefined(Concept C, DLTree D)
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)
boolean	axiomToRangeDomain(DLTree sub, DLTree sup)
void	buildDAG()
void	buildSimpleCache()
List<Concept>	c_begin()
void	calculateStatistic()
void	calculateTSDepth() calculate TS depth for all concepts
boolean	canUseSortedReasoning() check if Sorted Reasoning is applicable
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	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) create atmost node for data role
int	dataForall2dag(Role R, int C) create forall node for data role
void	determineSorts()
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(List<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)
Individual	getBlockingInd(Concept C) get individual that blocks C; works only for blocked individuals C
Concept	getCI(DLTree name) get TOP/BOTTOM/CN/IN by the DLTree entry
Concept	getConcept(String name) return registered concept by given NAME; @return null if can't register
DLDag	getDag() get RO access to DAG (needed for KE)
String	getDataEntryByBP(int bp) get concept by it's BP (non- version)
List<List<Individual>>	getDifferent()
DLDag	getDLHeap()
RoleMaster	getDRM() get RW access to used DataRole Master
List<Concept>	getFairness()
DLTree	getFreshConcept() get fresh concept
KBFlags	getGCIs()
Individual	getIndividual(String name) return registered individual by given NAME; @return null if can't register
int	getNItems()
JFactReasonerConfiguration	getOptions()
RoleMaster	getORM() get RW access to used Role Master
DlSatTester	getReasoner() get RW reasoner wrt nominal case
List<Related>	getRelatedI()
RoleMaster	getRM(Role R) get RW access to the RoleMaster depending of the R
uk.ac.manchester.cs.jfact.kernel.SimpleRule	getSimpleRule(int index) get simple rule by its INDEX
Individual	getSPForConcept(Concept p)
KBStatus	getStatus() get status flag
DLConceptTaxonomy	getTaxonomy() get (READ-WRITE) access to internal Taxonomy of concepts
int	getTG() GCI Axioms access
DLTree	getTree(Concept C) get a DL tree by a given concept-like C
boolean	hasFC()
List<Individual>	i_begin() RW begin() for individuals
ModelCacheInterface	initCache(Concept pConcept, boolean sub)
boolean	initNonPrimitive(Concept p, DLTree desc) add description to a concept; @return true in case of error
void	initRangeDomain(RoleMaster RM)
void	initReasoner()
void	initRuleFields(List<Concept> v, int index) init Extra Rule field in concepts given by a vector V with a given INDEX
void	initToldSubsumers() set told TOP concept whether necessary
boolean	isBlockedInd(Concept C)
boolean	isBlockingDet(Concept C)
AtomicBoolean	isCancelled()
boolean	isConsistent() check if the ontology is consistent
boolean	isDisjointRoles(Role R, Role S)
boolean	isIndividual(DLTree tree)
boolean	isIRinQuery() check if the relevant part of KB contains inverse roles.
boolean	isIrreflexive(Role R) check if the role R is irreflexive
boolean	isNRinQuery() check if the relevant part of KB contains number restrictions.
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; @return it's old description
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()
void	preprocess()
void	preprocessRelated()
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()
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)
int	reflexive2dag(Role R) create REFLEXIVE node
void	registerIndividualRelation(NamedEntry a, NamedEntry R, NamedEntry b) individual relation :R
void	removeExtraDescriptions()
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; @return old value
void	setToDoPriorities() set ToDo 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() check if the relevant part of KB contains singletons
boolean	testHasTopRole() check if the relevant part of KB contains top role
boolean	testSortedNonSubsumption(Concept p, Concept q) test if 2 concept non-subsumption can be determined by sorts checking
void	transformSingletonHierarchy()
void	transformToldCycles()
int	tree2dag(DLTree t)
void	writeReasoningResult(long time)

Methods inherited from class java.lang.Object

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

Field Detail

nC

@PortedFrom(file="dlTBox.h",
            name="nC")
protected int nC

number of concepts and individuals; used to set index for modelCache

nR

@PortedFrom(file="dlTBox.h",
            name="nR")
protected int nR

number of all distinct roles; used to set index for modelCache

Constructor Detail

TBox

public TBox(DatatypeFactory datatypeFactory,
    JFactReasonerConfiguration configuration,
    String topObjectRoleName,
    String botObjectRoleName,
    String topDataRoleName,
    String botDataRoleName,
    AtomicBoolean interrupted)

Parameters:

datatypeFactory -

configuration -

topObjectRoleName -

botObjectRoleName -

topDataRoleName -

botDataRoleName -

interrupted -

Method Detail

i_begin

@PortedFrom(file="dlTBox.h",
            name="i_begin")
public List<Individual> i_begin()

RW begin() for individuals

c_begin

@PortedFrom(file="dlTBox.h",
            name="c_begin")
public List<Concept> c_begin()

getOptions

@Original
public JFactReasonerConfiguration getOptions()

getDataEntryByBP

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

get concept by it's BP (non- version)

initNonPrimitive

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

add description to a concept; @return true in case of error

makeNonPrimitive

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

make concept non-primitive; @return 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

processDisjoint

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

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

reflexive2dag

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

create REFLEXIVE node

dataForall2dag

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

create forall node for data role

dataAtMost2dag

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

create atmost node for data role

concept2dag

@PortedFrom(file="dlTBox.h",
            name="concept2dag")
public int concept2dag(Concept 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

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

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

getReasoner

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

get RW reasoner wrt nominal case

printConcepts

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

print all registered concepts

printIndividuals

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

print all registered individuals

printSimpleRules

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

printAxioms

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

isIrreflexive

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

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()

get 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()

get RW access to used Role Master

getDRM

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

get RW access to used DataRole Master

getRM

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

get RW access to the RoleMaster depending of the R

getDag

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

get RO access to DAG (needed for KE)

getConcept

@PortedFrom(file="dlTBox.h",
            name="getConcept")
public Concept getConcept(String name)

return registered concept by given NAME; @return null if can't register

getIndividual

@PortedFrom(file="dlTBox.h",
            name="getIndividual")
public Individual getIndividual(String name)

return registered individual by given NAME; @return null if can't register

isIndividual

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

Returns:

true iff given TREE represents a registered individual

getCI

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

get TOP/BOTTOM/CN/IN by the DLTree entry

getTree

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

get 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; @return old value

registerIndividualRelation

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

individual relation :R

addSubsumeAxiom

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

add axiom CN [= D for concept CN

addSimpleRule

@PortedFrom(file="dlTBox.h",
            name="addSimpleRule")
public void addSimpleRule(uk.ac.manchester.cs.jfact.kernel.SimpleRule Rule)

add simple rule RULE to the TBox' rules

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)

getTG

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

GCI Axioms access

getSimpleRule

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

get simple rule by its INDEX

isIRinQuery

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

check if the relevant part of KB contains inverse roles.

isNRinQuery

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

check if the relevant part of KB contains number restrictions.

testHasNominals

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

check if the relevant part of KB contains singletons

testHasTopRole

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

check if the relevant part of KB contains top role

canUseSortedReasoning

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

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 DLConceptTaxonomy getTaxonomy()

get (READ-WRITE) access to internal Taxonomy of concepts

getStatus

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

get status flag

setConsistency

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

set consistency flag

isConsistent

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

check if the ontology is consistent

testSortedNonSubsumption

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

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()

initRangeDomain

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

addDataExprToHeap

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

addDataExprToHeap

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

addDatatypeExpressionToHeap

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

addConceptToHeap

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

tree2dag

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

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

forall2dag

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

atmost2dag

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

fillArrays

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

getNItems

@Original
public int getNItems()

createTaxonomy

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

classifyConcepts

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

prepareReasoning

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

prepareFeatures

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

buildSimpleCache

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

performConsistencyCheck

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

isSatisfiable

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

isSubHolds

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

isSameIndividuals

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

isDisjointRoles

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

createQueryConcept

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

classifyQueryConcept

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

classify query concept

writeReasoningResult

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

printDagEntry

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

printConcept

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

dumpConcept

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

dumpRole

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

dumpExpression

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

dumpAllRoles

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

addSubsumeAxiom

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

applyAxiomCToCN

@PortedFrom(file="dlTBox.h",
            name="applyAxiomCToCN")
public DLTree applyAxiomCToCN(DLTree D,
                                        DLTree CN)

applyAxiomCNToC

@PortedFrom(file="dlTBox.h",
            name="applyAxiomCNToC")
public DLTree applyAxiomCNToC(DLTree CN,
                                        DLTree D)

addSubsumeForDefined

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

axiomToRangeDomain

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

addNonprimitiveDefinition

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

switchToNonprimitive

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

processDisjointC

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

processEquivalentC

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

processDifferent

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

processSame

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

processDisjointR

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

processEquivalentR

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

preprocess

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

preprocessRelated

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

transformToldCycles

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

checkToldCycle

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

transformSingletonHierarchy

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

getSPForConcept

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

determineSorts

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

calculateStatistic

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

removeExtraDescriptions

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

setToDoPriorities

@Original
public void setToDoPriorities()

set ToDo priorities using local OPTIONS

isBlockedInd

@PortedFrom(file="dlTBox.h",
            name="isBlockedInd")
public boolean isBlockedInd(Concept 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)

get individual that blocks C; works only for blocked individuals C

isBlockingDet

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

Returns:

true iff an individual blocks C deterministically

initCache

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

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

initReasoner

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

printFeatures

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

getDifferent

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

getRelatedI

@Original
public List<Related> getRelatedI()

getDLHeap

@Original
public DLDag getDLHeap()

getGCIs

@Original
public KBFlags getGCIs()

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. @return X

isCancelled

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

getFairness

@Original
public List<Concept> getFairness()