uk.ac.manchester.cs.jfact.kernel

Class ReasoningKernel

java.lang.Object

uk.ac.manchester.cs.jfact.kernel.ReasoningKernel

@PortedFrom(file="Kernel.h",
            name="ReasoningKernel")
public class ReasoningKernel
extends Object

Constructor Summary

Constructors

Constructor and Description
ReasoningKernel(JFactReasonerConfiguration conf, DatatypeFactory factory)

Method Summary

Methods

Modifier and Type	Method and Description
DlCompletionTree	buildCompletionTree(ConceptExpression C) build a completion tree for a concept expression C (no caching as it breaks the idea of KE).
void	classifyKB() ensure that KB is classified
boolean	clearKB() reset current KB
Axiom	declare(org.semanticweb.owlapi.model.OWLAxiom ax, Expression C) axiom declare(x)
Axiom	disjointConcepts(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) axiom C1 != ...
Axiom	disjointDRoles(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) axiom R1 != R2 != ...
Axiom	disjointORoles(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) axiom R1 != R2 != ...
Axiom	disjointUnion(org.semanticweb.owlapi.model.OWLAxiom ax, ConceptExpression C, List<Expression> l) axiom C = C1 or ...
Axiom	equalConcepts(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) axiom C1 = ...
Axiom	equalDRoles(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) axiom R1 = R2 = ...
Axiom	equalORoles(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) axiom R1 = R2 = ...
Set<Axiom>	getAtomAxioms(int index) get a set of axioms that corresponds to the atom with the id INDEX
Set<TOntologyAtom>	getAtomDependents(int index) get a set of atoms on which atom with index INDEX depends
int	getAtomicDecompositionSize(boolean useSemantics, ModuleType type) create new atomic decomposition of the loaded ontology using TYPE.
Set<Axiom>	getAtomModule(int index) get a set of axioms that corresponds to the module of the atom with the id INDEX
List<DataExpression>	getDataLabel(DlCompletionTree node, boolean onlyDet)
Set<RoleExpression>	getDataRoles(DlCompletionTree node, boolean onlyDet) build the set of data neighbours of a NODE, put the set of data roles into the RESULT variable
void	getDirectInstances(ConceptExpression C, Actor actor) apply actor__apply() to all direct instances of given [complex] C
void	getDisjointConcepts(ConceptExpression C, Actor actor) apply actor::apply() to all named concepts disjoint with [complex] C
void	getEquivalentConcepts(ConceptExpression C, Actor actor) apply actor__apply() to all synonyms of [complex] C
void	getEquivalentRoles(RoleExpression r, Actor actor) apply actor__apply() to all synonyms of [complex] R
ExpressionManager	getExpressionManager() get access to an expression manager
void	getInstances(ConceptExpression C, Actor actor) apply actor__apply() to all instances of given [complex] C
void	getInstances(ConceptExpression C, Actor actor, boolean direct)
KnowledgeExplorer	getKnowledgeExplorer()
TModularizer	getModExtractor(boolean useSemantic)
List<Axiom>	getModule(List<Expression> signature, boolean useSemantic, ModuleType type) get a set of axioms that corresponds to the atom with the id INDEX
List<DlCompletionTree>	getNeighbours(DlCompletionTree node, RoleExpression role) build the set of neighbours of a NODE via role ROLE; put the resulting list into RESULT
Set<Axiom>	getNonLocal(List<Expression> signature, boolean useSemantic, ModuleType type) get a set of axioms that corresponds to the atom with the id INDEX
List<ConceptExpression>	getObjectLabel(DlCompletionTree node, boolean onlyDet) put into RESULT all the expressions from the NODE label; if ONLYDET is true, return only deterministic elements
Set<RoleExpression>	getObjectRoles(DlCompletionTree node, boolean onlyDet, boolean needIncoming) build the set of object neighbours of a NODE, put the set of object roles and inverses into the RESULT variable
void	getORoleDomain(ObjectRoleExpression r, boolean direct, Actor actor) apply actor__apply() to all DIRECT NC that are in the domain of [complex] R
List<Individual>	getRoleFillers(IndividualExpression I, ObjectRoleExpression R)
void	getRoleRange(ObjectRoleExpression r, boolean direct, Actor actor) apply actor__apply() to all DIRECT NC that are in the range of [complex] R
void	getSameAs(IndividualExpression I, Actor actor) apply actor__apply() to all synonyms of an individual I
void	getSubConcepts(ConceptExpression C, boolean direct, Actor actor) apply actor__apply() to all DIRECT sub-concepts of [complex] C
void	getSubRoles(RoleExpression r, boolean direct, Actor actor) apply actor__apply() to all DIRECT sub-roles of [complex] R
void	getSupConcepts(ConceptExpression C, boolean direct, Actor actor) apply actor__apply() to all DIRECT super-concepts of [complex] C
void	getSupRoles(RoleExpression r, boolean direct, Actor actor) apply actor__apply() to all DIRECT super-roles of [complex] R
List<Axiom>	getTautologies()
List<Axiom>	getTrace()
void	getTypes(IndividualExpression I, boolean direct, Actor actor) apply actor__apply() to all DIRECT concepts that are types of an individual I
Axiom	impliesConcepts(org.semanticweb.owlapi.model.OWLAxiom ax, ConceptExpression C, ConceptExpression D) axiom C [= D
Axiom	impliesDRoles(org.semanticweb.owlapi.model.OWLAxiom ax, DataRoleExpression R, DataRoleExpression S) axiom (R [= S)
Axiom	impliesORoles(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleComplexExpression R, ObjectRoleExpression S) axiom (R [= S)
Axiom	instanceOf(org.semanticweb.owlapi.model.OWLAxiom ax, IndividualExpression I, ConceptExpression C) axiom I e C
boolean	isAsymmetric(ObjectRoleExpression R)
boolean	isDisjoint(ConceptExpression C, ConceptExpression D)
boolean	isDisjointRoles(DataRoleExpression R, DataRoleExpression S)
boolean	isDisjointRoles(List<? extends RoleExpression> l)
boolean	isDisjointRoles(ObjectRoleExpression R, ObjectRoleExpression S)
boolean	isEquivalent(ConceptExpression C, ConceptExpression D)
boolean	isFunctional(DataRoleExpression R)
boolean	isFunctional(ObjectRoleExpression R)
boolean	isInstance(IndividualExpression I, ConceptExpression C)
boolean	isInverseFunctional(ObjectRoleExpression R)
boolean	isIrreflexive(ObjectRoleExpression R)
boolean	isKBClassified() return classification status of KB
boolean	isKBConsistent() return consistency status of KB
boolean	isKBPreprocessed() return classification status of KB
boolean	isKBRealised() return realistion status of KB
boolean	isReflexive(ObjectRoleExpression R)
boolean	isRelated(IndividualExpression I, ObjectRoleExpression R, IndividualExpression J)
boolean	isSameIndividuals(IndividualExpression I, IndividualExpression J)
boolean	isSatisfiable(ConceptExpression C)
boolean	isSubChain(ObjectRoleComplexExpression R, List<ObjectRoleExpression> l)
boolean	isSubRoles(DataRoleExpression R, DataRoleExpression S)
boolean	isSubRoles(ObjectRoleComplexExpression R, ObjectRoleExpression S)
boolean	isSubsumedBy(ConceptExpression C, ConceptExpression D)
boolean	isSymmetric(ObjectRoleExpression R)
boolean	isTransitive(ObjectRoleExpression R)
void	needTracing()
Axiom	processDifferent(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) different individuals
Axiom	processSame(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) same individuals
void	realiseKB() ensure that KB is realised
Axiom	relatedTo(org.semanticweb.owlapi.model.OWLAxiom ax, IndividualExpression I, ObjectRoleExpression R, IndividualExpression J) axiom :R
Axiom	relatedToNot(org.semanticweb.owlapi.model.OWLAxiom ax, IndividualExpression I, ObjectRoleExpression R, IndividualExpression J) axiom :\neg R
void	retract(Axiom axiom) retract an axiom
Axiom	setAsymmetric(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) AntySymmetric (R): disjoint(R,R^-)
Axiom	setDDomain(org.semanticweb.owlapi.model.OWLAxiom ax, DataRoleExpression R, ConceptExpression C) Domain (R C)
Axiom	setDFunctional(org.semanticweb.owlapi.model.OWLAxiom ax, DataRoleExpression R) Functional (R)
Axiom	setDRange(org.semanticweb.owlapi.model.OWLAxiom ax, DataRoleExpression R, DataExpression E) Range (R E)
Axiom	setFairnessConstraint(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) let all concept expressions in the ArgQueue to be fairness constraints
void	setIgnoreExprCache(boolean value) choose whether TExpr cache should be ignored
void	setInterruptedSwitch(AtomicBoolean b)
Axiom	setInverseFunctional(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) InverseFunctional (R)
Axiom	setInverseRoles(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R, ObjectRoleExpression S) R = Inverse(S)
Axiom	setIrreflexive(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) Irreflexive (R): Domain(R) = \neg ER.Self
Axiom	setODomain(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R, ConceptExpression C) Domain (R C)
Axiom	setOFunctional(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) Functional (R)
Axiom	setORange(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R, ConceptExpression C) Range (R C)
Axiom	setReflexive(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) Reflexive (R)
void	setSignature(TSignature sig) set the signature of the expression translator
Axiom	setSymmetric(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) Symmetric (R): R [= R^-
void	setTopBottomRoleNames(String topO, String botO, String topD, String botD) set top/bottom role names to use them in the related output
Axiom	setTransitive(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) Transitive (R)
Axiom	valueOf(org.semanticweb.owlapi.model.OWLAxiom ax, IndividualExpression I, DataRoleExpression A, Literal<?> V) axiom (value I A V)
Axiom	valueOfNot(org.semanticweb.owlapi.model.OWLAxiom ax, IndividualExpression I, DataRoleExpression A, Literal<?> V) axiom :\neg A
void	writeReasoningResult(LogAdapter o, long time) dump query processing TIME, reasoning statistics and a (preprocessed) TBox

Methods inherited from class java.lang.Object

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

Constructor Detail

ReasoningKernel

public ReasoningKernel(JFactReasonerConfiguration conf,
               DatatypeFactory factory)

Method Detail

setInterruptedSwitch

@Original
public void setInterruptedSwitch(AtomicBoolean b)

setIgnoreExprCache

@PortedFrom(file="Kernel.h",
            name="setIgnoreExprCache")
public void setIgnoreExprCache(boolean value)

choose whether TExpr cache should be ignored

needTracing

@PortedFrom(file="Kernel.h",
            name="needTracing")
public void needTracing()

getTrace

@PortedFrom(file="Kernel.h",
            name="getTrace")
public List<Axiom> getTrace()

Returns:

the trace-set of the last reasoning operation

setSignature

@PortedFrom(file="Kernel.h",
            name="setSignature")
public void setSignature(TSignature sig)

set the signature of the expression translator

disjointUnion

@PortedFrom(file="Kernel.h",
            name="disjointUnion")
public Axiom disjointUnion(org.semanticweb.owlapi.model.OWLAxiom ax,
                                     ConceptExpression C,
                                     List<Expression> l)

axiom C = C1 or ... or Cn; C1 != ... != Cn

getModExtractor

@PortedFrom(file="Kernel.h",
            name="getModExtractor")
public TModularizer getModExtractor(boolean useSemantic)

getModule

@PortedFrom(file="Kernel.h",
            name="getModule")
public List<Axiom> getModule(List<Expression> signature,
                                       boolean useSemantic,
                                       ModuleType type)

get a set of axioms that corresponds to the atom with the id INDEX

getNonLocal

@PortedFrom(file="Kernel.h",
            name="getNonLocal")
public Set<Axiom> getNonLocal(List<Expression> signature,
                                        boolean useSemantic,
                                        ModuleType type)

get a set of axioms that corresponds to the atom with the id INDEX

isKBPreprocessed

@PortedFrom(file="Kernel.h",
            name="isKBPreprocessed")
public boolean isKBPreprocessed()

return classification status of KB

isKBClassified

@PortedFrom(file="Kernel.h",
            name="isKBClassified")
public boolean isKBClassified()

return classification status of KB

isKBRealised

@PortedFrom(file="Kernel.h",
            name="isKBRealised")
public boolean isKBRealised()

return realistion status of KB

setTopBottomRoleNames

@PortedFrom(file="Kernel.h",
            name="setTopBottomRoleNames")
public void setTopBottomRoleNames(String topO,
                                            String botO,
                                            String topD,
                                            String botD)

set top/bottom role names to use them in the related output

writeReasoningResult

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

dump query processing TIME, reasoning statistics and a (preprocessed) TBox

getExpressionManager

@PortedFrom(file="Kernel.h",
            name="getExpressionManager")
public ExpressionManager getExpressionManager()

get access to an expression manager

clearKB

@PortedFrom(file="Kernel.h",
            name="clearKB")
public boolean clearKB()

reset current KB

declare

@PortedFrom(file="Kernel.h",
            name="declare")
public Axiom declare(org.semanticweb.owlapi.model.OWLAxiom ax,
                               Expression C)

axiom declare(x)

impliesConcepts

@PortedFrom(file="Kernel.h",
            name="impliesConcepts")
public Axiom impliesConcepts(org.semanticweb.owlapi.model.OWLAxiom ax,
                                       ConceptExpression C,
                                       ConceptExpression D)

axiom C [= D

equalConcepts

@PortedFrom(file="Kernel.h",
            name="equalConcepts")
public Axiom equalConcepts(org.semanticweb.owlapi.model.OWLAxiom ax,
                                     List<Expression> l)

axiom C1 = ... = Cn

disjointConcepts

@PortedFrom(file="Kernel.h",
            name="disjointConcepts")
public Axiom disjointConcepts(org.semanticweb.owlapi.model.OWLAxiom ax,
                                        List<Expression> l)

axiom C1 != ... != Cn

setInverseRoles

@PortedFrom(file="Kernel.h",
            name="setInverseRoles")
public Axiom setInverseRoles(org.semanticweb.owlapi.model.OWLAxiom ax,
                                       ObjectRoleExpression R,
                                       ObjectRoleExpression S)

R = Inverse(S)

impliesORoles

@PortedFrom(file="Kernel.h",
            name="impliesORoles")
public Axiom impliesORoles(org.semanticweb.owlapi.model.OWLAxiom ax,
                                     ObjectRoleComplexExpression R,
                                     ObjectRoleExpression S)

axiom (R [= S)

impliesDRoles

@PortedFrom(file="Kernel.h",
            name="impliesDRoles")
public Axiom impliesDRoles(org.semanticweb.owlapi.model.OWLAxiom ax,
                                     DataRoleExpression R,
                                     DataRoleExpression S)

axiom (R [= S)

equalORoles

@PortedFrom(file="Kernel.h",
            name="equalORoles")
public Axiom equalORoles(org.semanticweb.owlapi.model.OWLAxiom ax,
                                   List<Expression> l)

axiom R1 = R2 = ...

equalDRoles

@PortedFrom(file="Kernel.h",
            name="equalDRoles")
public Axiom equalDRoles(org.semanticweb.owlapi.model.OWLAxiom ax,
                                   List<Expression> l)

axiom R1 = R2 = ...

disjointORoles

@PortedFrom(file="Kernel.h",
            name="disjointORoles")
public Axiom disjointORoles(org.semanticweb.owlapi.model.OWLAxiom ax,
                                      List<Expression> l)

axiom R1 != R2 != ...

disjointDRoles

@PortedFrom(file="Kernel.h",
            name="disjointDRoles")
public Axiom disjointDRoles(org.semanticweb.owlapi.model.OWLAxiom ax,
                                      List<Expression> l)

axiom R1 != R2 != ...

setODomain

@PortedFrom(file="Kernel.h",
            name="setODomain")
public Axiom setODomain(org.semanticweb.owlapi.model.OWLAxiom ax,
                                  ObjectRoleExpression R,
                                  ConceptExpression C)

Domain (R C)

setDDomain

@PortedFrom(file="Kernel.h",
            name="setDDomain")
public Axiom setDDomain(org.semanticweb.owlapi.model.OWLAxiom ax,
                                  DataRoleExpression R,
                                  ConceptExpression C)

Domain (R C)

setORange

@PortedFrom(file="Kernel.h",
            name="setORange")
public Axiom setORange(org.semanticweb.owlapi.model.OWLAxiom ax,
                                 ObjectRoleExpression R,
                                 ConceptExpression C)

Range (R C)

setDRange

@PortedFrom(file="Kernel.h",
            name="setDRange")
public Axiom setDRange(org.semanticweb.owlapi.model.OWLAxiom ax,
                                 DataRoleExpression R,
                                 DataExpression E)

Range (R E)

setTransitive

@PortedFrom(file="Kernel.h",
            name="setTransitive")
public Axiom setTransitive(org.semanticweb.owlapi.model.OWLAxiom ax,
                                     ObjectRoleExpression R)

Transitive (R)

setReflexive

@PortedFrom(file="Kernel.h",
            name="setReflexive")
public Axiom setReflexive(org.semanticweb.owlapi.model.OWLAxiom ax,
                                    ObjectRoleExpression R)

Reflexive (R)

setIrreflexive

@PortedFrom(file="Kernel.h",
            name="setIrreflexive")
public Axiom setIrreflexive(org.semanticweb.owlapi.model.OWLAxiom ax,
                                      ObjectRoleExpression R)

Irreflexive (R): Domain(R) = \neg ER.Self

setSymmetric

@PortedFrom(file="Kernel.h",
            name="setSymmetric")
public Axiom setSymmetric(org.semanticweb.owlapi.model.OWLAxiom ax,
                                    ObjectRoleExpression R)

Symmetric (R): R [= R^-

setAsymmetric

@PortedFrom(file="Kernel.h",
            name="setAsymmetric")
public Axiom setAsymmetric(org.semanticweb.owlapi.model.OWLAxiom ax,
                                     ObjectRoleExpression R)

AntySymmetric (R): disjoint(R,R^-)

setOFunctional

@PortedFrom(file="Kernel.h",
            name="setOFunctional")
public Axiom setOFunctional(org.semanticweb.owlapi.model.OWLAxiom ax,
                                      ObjectRoleExpression R)

Functional (R)

setDFunctional

@PortedFrom(file="Kernel.h",
            name="setDFunctional")
public Axiom setDFunctional(org.semanticweb.owlapi.model.OWLAxiom ax,
                                      DataRoleExpression R)

Functional (R)

setInverseFunctional

@PortedFrom(file="Kernel.h",
            name="setInverseFunctional")
public Axiom setInverseFunctional(org.semanticweb.owlapi.model.OWLAxiom ax,
                                            ObjectRoleExpression R)

InverseFunctional (R)

instanceOf

@PortedFrom(file="Kernel.h",
            name="instanceOf")
public Axiom instanceOf(org.semanticweb.owlapi.model.OWLAxiom ax,
                                  IndividualExpression I,
                                  ConceptExpression C)

axiom I e C

relatedTo

@PortedFrom(file="Kernel.h",
            name="relatedTo")
public Axiom relatedTo(org.semanticweb.owlapi.model.OWLAxiom ax,
                                 IndividualExpression I,
                                 ObjectRoleExpression R,
                                 IndividualExpression J)

axiom :R

relatedToNot

@PortedFrom(file="Kernel.h",
            name="relatedToNot")
public Axiom relatedToNot(org.semanticweb.owlapi.model.OWLAxiom ax,
                                    IndividualExpression I,
                                    ObjectRoleExpression R,
                                    IndividualExpression J)

axiom :\neg R

valueOf

@PortedFrom(file="Kernel.h",
            name="valueOf")
public Axiom valueOf(org.semanticweb.owlapi.model.OWLAxiom ax,
                               IndividualExpression I,
                               DataRoleExpression A,
                               Literal<?> V)

axiom (value I A V)

valueOfNot

@PortedFrom(file="Kernel.h",
            name="valueOfNot")
public Axiom valueOfNot(org.semanticweb.owlapi.model.OWLAxiom ax,
                                  IndividualExpression I,
                                  DataRoleExpression A,
                                  Literal<?> V)

axiom :\neg A

processSame

@PortedFrom(file="Kernel.h",
            name="processSame")
public Axiom processSame(org.semanticweb.owlapi.model.OWLAxiom ax,
                                   List<Expression> l)

same individuals

processDifferent

@PortedFrom(file="Kernel.h",
            name="processDifferent")
public Axiom processDifferent(org.semanticweb.owlapi.model.OWLAxiom ax,
                                        List<Expression> l)

different individuals

setFairnessConstraint

@PortedFrom(file="Kernel.h",
            name="setFairnessConstraint")
public Axiom setFairnessConstraint(org.semanticweb.owlapi.model.OWLAxiom ax,
                                             List<Expression> l)

let all concept expressions in the ArgQueue to be fairness constraints

retract

@PortedFrom(file="Kernel.h",
            name="retract")
public void retract(Axiom axiom)

retract an axiom

isKBConsistent

@PortedFrom(file="Kernel.h",
            name="isKBConsistent")
public boolean isKBConsistent()

return consistency status of KB

classifyKB

@PortedFrom(file="Kernel.h",
            name="classifyKB")
public void classifyKB()

ensure that KB is classified

realiseKB

@PortedFrom(file="Kernel.h",
            name="realiseKB")
public void realiseKB()

ensure that KB is realised

isFunctional

@PortedFrom(file="Kernel.h",
            name="isFunctional")
public boolean isFunctional(ObjectRoleExpression R)

Returns:

true iff object role is functional

isFunctional

@PortedFrom(file="Kernel.h",
            name="isFunctional")
public boolean isFunctional(DataRoleExpression R)

Returns:

true iff data role is functional

isInverseFunctional

@PortedFrom(file="Kernel.h",
            name="isInverseFunctional")
public boolean isInverseFunctional(ObjectRoleExpression R)

Returns:

true iff role is inverse-functional

isTransitive

@PortedFrom(file="Kernel.h",
            name="isTransitive")
public boolean isTransitive(ObjectRoleExpression R)

Returns:

true iff role is transitive

isSymmetric

@PortedFrom(file="Kernel.h",
            name="isSymmetric")
public boolean isSymmetric(ObjectRoleExpression R)

Returns:

true iff role is symmetric

isAsymmetric

@PortedFrom(file="Kernel.h",
            name="isAsymmetric")
public boolean isAsymmetric(ObjectRoleExpression R)

Returns:

true iff role is asymmetric

isReflexive

@PortedFrom(file="Kernel.h",
            name="isReflexive")
public boolean isReflexive(ObjectRoleExpression R)

Returns:

true iff role is reflexive

isIrreflexive

@PortedFrom(file="Kernel.h",
            name="isIrreflexive")
public boolean isIrreflexive(ObjectRoleExpression R)

Returns:

true iff role is irreflexive

isDisjointRoles

@PortedFrom(file="Kernel.h",
            name="isDisjointRoles")
public boolean isDisjointRoles(List<? extends RoleExpression> l)

isDisjointRoles

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

Returns:

true iff two roles are disjoint

isDisjointRoles

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

Returns:

true iff two roles are disjoint

isSubRoles

@PortedFrom(file="Kernel.h",
            name="isSubRoles")
public boolean isSubRoles(ObjectRoleComplexExpression R,
                                    ObjectRoleExpression S)

Returns:

true if R is a sub-role of S

isSatisfiable

@PortedFrom(file="Kernel.h",
            name="isSatisfiable")
public boolean isSatisfiable(ConceptExpression C)

Returns:

true iff C is satisfiable

isSubsumedBy

@PortedFrom(file="Kernel.h",
            name="isSubsumedBy")
public boolean isSubsumedBy(ConceptExpression C,
                                      ConceptExpression D)

Returns:

true iff C [= D holds

isDisjoint

@PortedFrom(file="Kernel.h",
            name="isDisjoint")
public boolean isDisjoint(ConceptExpression C,
                                    ConceptExpression D)

Returns:

true iff C is disjoint with D; that is, C [= \not D holds

isEquivalent

@PortedFrom(file="Kernel.h",
            name="isEquivalent")
public boolean isEquivalent(ConceptExpression C,
                                      ConceptExpression D)

Returns:

true iff C is equivalent to D

getSupConcepts

@PortedFrom(file="Kernel.h",
            name="getSupConcepts")
public void getSupConcepts(ConceptExpression C,
                                     boolean direct,
                                     Actor actor)

apply actor__apply() to all DIRECT super-concepts of [complex] C

getSubConcepts

@PortedFrom(file="Kernel.h",
            name="getSubConcepts")
public void getSubConcepts(ConceptExpression C,
                                     boolean direct,
                                     Actor actor)

apply actor__apply() to all DIRECT sub-concepts of [complex] C

getEquivalentConcepts

@PortedFrom(file="Kernel.h",
            name="getEquivalentConcepts")
public void getEquivalentConcepts(ConceptExpression C,
                                            Actor actor)

apply actor__apply() to all synonyms of [complex] C

getDisjointConcepts

@PortedFrom(file="Kernel.h",
            name="getDisjointConcepts")
public void getDisjointConcepts(ConceptExpression C,
                                          Actor actor)

apply actor::apply() to all named concepts disjoint with [complex] C

getSupRoles

@PortedFrom(file="Kernel.h",
            name="getSupRoles")
public void getSupRoles(RoleExpression r,
                                  boolean direct,
                                  Actor actor)

apply actor__apply() to all DIRECT super-roles of [complex] R

getSubRoles

@PortedFrom(file="Kernel.h",
            name="getSubRoles")
public void getSubRoles(RoleExpression r,
                                  boolean direct,
                                  Actor actor)

apply actor__apply() to all DIRECT sub-roles of [complex] R

getEquivalentRoles

@PortedFrom(file="Kernel.h",
            name="getEquivalentRoles")
public void getEquivalentRoles(RoleExpression r,
                                         Actor actor)

apply actor__apply() to all synonyms of [complex] R

getORoleDomain

@PortedFrom(file="Kernel.h",
            name="getORoleDomain")
public void getORoleDomain(ObjectRoleExpression r,
                                     boolean direct,
                                     Actor actor)

apply actor__apply() to all DIRECT NC that are in the domain of [complex] R

getRoleRange

@PortedFrom(file="Kernel.h",
            name="getRoleRange")
public void getRoleRange(ObjectRoleExpression r,
                                   boolean direct,
                                   Actor actor)

apply actor__apply() to all DIRECT NC that are in the range of [complex] R

getInstances

@PortedFrom(file="Kernel.h",
            name="getInstances")
public void getInstances(ConceptExpression C,
                                   Actor actor,
                                   boolean direct)

getDirectInstances

@PortedFrom(file="Kernel.h",
            name="getDirectInstances")
public void getDirectInstances(ConceptExpression C,
                                         Actor actor)

apply actor__apply() to all direct instances of given [complex] C

getInstances

@PortedFrom(file="Kernel.h",
            name="getInstances")
public void getInstances(ConceptExpression C,
                                   Actor actor)

apply actor__apply() to all instances of given [complex] C

getTypes

@PortedFrom(file="Kernel.h",
            name="getTypes")
public void getTypes(IndividualExpression I,
                               boolean direct,
                               Actor actor)

apply actor__apply() to all DIRECT concepts that are types of an individual I

getSameAs

@PortedFrom(file="Kernel.h",
            name="getSameAs")
public void getSameAs(IndividualExpression I,
                                Actor actor)

apply actor__apply() to all synonyms of an individual I

isSameIndividuals

@PortedFrom(file="Kernel.h",
            name="isSameIndividuals")
public boolean isSameIndividuals(IndividualExpression I,
                                           IndividualExpression J)

Returns:

true iff I and J refer to the same individual

buildCompletionTree

@PortedFrom(file="Kernel.h",
            name="buildCompletionTree")
public DlCompletionTree buildCompletionTree(ConceptExpression C)

build a completion tree for a concept expression C (no caching as it breaks the idea of KE). @return the root node

getKnowledgeExplorer

@Original
public KnowledgeExplorer getKnowledgeExplorer()

getDataRoles

@PortedFrom(file="Kernel.h",
            name="getDataRoles")
public Set<RoleExpression> getDataRoles(DlCompletionTree node,
                                                  boolean onlyDet)

build the set of data neighbours of a NODE, put the set of data roles into the RESULT variable

getObjectRoles

@PortedFrom(file="Kernel.h",
            name="getObjectRoles")
public Set<RoleExpression> getObjectRoles(DlCompletionTree node,
                                                    boolean onlyDet,
                                                    boolean needIncoming)

build the set of object neighbours of a NODE, put the set of object roles and inverses into the RESULT variable

getNeighbours

@PortedFrom(file="Kernel.h",
            name="getNeighbours")
public List<DlCompletionTree> getNeighbours(DlCompletionTree node,
                                                      RoleExpression role)

build the set of neighbours of a NODE via role ROLE; put the resulting list into RESULT

getObjectLabel

@PortedFrom(file="Kernel.h",
            name="getLabel")
public List<ConceptExpression> getObjectLabel(DlCompletionTree node,
                                                        boolean onlyDet)

put into RESULT all the expressions from the NODE label; if ONLYDET is true, return only deterministic elements

getDataLabel

@PortedFrom(file="Kernel.h",
            name="getLabel")
public List<DataExpression> getDataLabel(DlCompletionTree node,
                                                   boolean onlyDet)

isInstance

@PortedFrom(file="Kernel.h",
            name="isInstance")
public boolean isInstance(IndividualExpression I,
                                    ConceptExpression C)

Returns:

true iff individual I is instance of given [complex] C

getAtomicDecompositionSize

@PortedFrom(file="Kernel.h",
            name="getAtomicDecompositionSize")
public int getAtomicDecompositionSize(boolean useSemantics,
                                                ModuleType type)

create new atomic decomposition of the loaded ontology using TYPE. @return size of the AD

getAtomAxioms

@PortedFrom(file="Kernel.h",
            name="getAtomAxioms")
public Set<Axiom> getAtomAxioms(int index)

get a set of axioms that corresponds to the atom with the id INDEX

getTautologies

@Original
public List<Axiom> getTautologies()

getAtomModule

@PortedFrom(file="Kernel.h",
            name="getAtomModule")
public Set<Axiom> getAtomModule(int index)

get a set of axioms that corresponds to the module of the atom with the id INDEX

getAtomDependents

@PortedFrom(file="Kernel.h",
            name="getAtomDependents")
public Set<TOntologyAtom> getAtomDependents(int index)

get a set of atoms on which atom with index INDEX depends

isSubChain

@PortedFrom(file="Kernel.h",
            name="isSubChain")
public boolean isSubChain(ObjectRoleComplexExpression R,
                                    List<ObjectRoleExpression> l)

Returns:

true if R is a super-role of a chain holding in the args

isSubRoles

@PortedFrom(file="Kernel.h",
            name="isSubRoles")
public boolean isSubRoles(DataRoleExpression R,
                                    DataRoleExpression S)

Returns:

true if R is a sub-role of S

getRoleFillers

@PortedFrom(file="Kernel.h",
            name="getRoleFillers")
public List<Individual> getRoleFillers(IndividualExpression I,
                                                 ObjectRoleExpression R)

isRelated

@PortedFrom(file="Kernel.h",
            name="isRelated")
public boolean isRelated(IndividualExpression I,
                                   ObjectRoleExpression R,
                                   IndividualExpression J)