uk.ac.manchester.cs.jfact.kernel

Class ReasoningKernel

java.lang.Object

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

All Implemented Interfaces:

Serializable

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

Reasoning kernel

See Also:

Serialized Form

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	buildSignature(NamedEntity entity, List<AxiomInterface> Module, Set<NamedEntity> toProcess) build signature for ENTITY and all dependent entities from toProcess; look for modules in Module;
void	classifyKB() ensure that KB is classified
boolean	clearKB() reset current KB
void	doIncremental() incrementally classify changes
DLTree	e(Expression expr)
Set<AxiomInterface>	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<AxiomInterface>	getAtomModule(int index) get a set of axioms that corresponds to the module of the atom with the id INDEX
DlCompletionTree	getBlocker(DlCompletionTree node)
Actor	getConcepts(ConceptExpression C, boolean direct, Actor actor, boolean supDirection) apply actor__apply() to all DIRECT sub-concepts of [complex] C
<T extends Expression> TaxonomyActor<T>	getConcepts(ConceptExpression C, boolean direct, TaxonomyActor<T> actor, boolean supDirection) apply actor__apply() to all super/sub-concepts of [complex] C
List<DataExpression>	getDataLabel(DlCompletionTree node, boolean onlyDet)
Collection<IndividualName>	getDataRelatedIndividuals(RoleExpression R, RoleExpression S, int op, Collection<IndividualExpression> individuals) set RESULT into set of instances of A such that they do have data roles R and S
Set<DataRoleExpression>	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
<T extends Expression> TaxonomyActor<T>	getDisjointConcepts(ConceptExpression C, TaxonomyActor<T> actor) apply actor::apply() to all named concepts disjoint with [complex] C
<T extends ConceptExpression> TaxonomyActor<T>	getDRoleDomain(DataRoleExpression r, boolean direct, TaxonomyActor<T> actor) apply actor::apply() to all DIRECT NC that are in the domain of data role R
<T extends Expression> TaxonomyActor<T>	getEquivalentConcepts(ConceptExpression C, TaxonomyActor<T> actor) apply actor__apply() to all synonyms of [complex] C
<T extends RoleExpression> TaxonomyActor<T>	getEquivalentRoles(RoleExpression r, TaxonomyActor<T> actor) apply actor__apply() to all synonyms of [complex] R
ExpressionCache	getExpressionManager()
void	getInstances(ConceptExpression C, Actor actor) apply actor__apply() to all instances of given [complex] C
TaxonomyActor<IndividualExpression>	getInstances(ConceptExpression C, TaxonomyActor<IndividualExpression> actor, boolean direct)
long	getLocCheckNumber()
OntologyBasedModularizer	getModExtractor(boolean useSemantic)
List<AxiomInterface>	getModule(List<Expression> signature, boolean useSemantic, ModuleType type)
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<AxiomInterface>	getNonLocal(List<Expression> signature, boolean useSemantic, ModuleType type)
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<ObjectRoleExpression>	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
Ontology	getOntology()
JFactReasonerConfiguration	getOptions()
<T extends ConceptExpression> TaxonomyActor<T>	getORoleDomain(ObjectRoleExpression r, boolean direct, TaxonomyActor<T> actor) apply actor__apply() to all DIRECT NC that are in the domain of [complex] R
List<Individual>	getRoleFillers(IndividualExpression I, ObjectRoleExpression R)
<T extends RoleExpression> TaxonomyActor<T>	getRoles(RoleExpression r, boolean direct, TaxonomyActor<T> actor, boolean supDirection) apply actor__apply() to all DIRECT super-roles of [complex] R
<T extends Expression> TaxonomyActor<T>	getSameAs(IndividualName I, TaxonomyActor<T> actor) apply actor__apply() to all synonyms of an individual I
List<AxiomInterface>	getTautologies()
TBox	getTBox()
List<AxiomInterface>	getTrace()
<T extends Expression> TaxonomyActor<T>	getTypes(IndividualName I, boolean direct, TaxonomyActor<T> actor) apply actor__apply() to all DIRECT concepts that are types of an individual I
void	initIncremental() initialise the incremental bits on full reload
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()
boolean	isKBConsistent()
boolean	isKBPreprocessed()
boolean	isKBRealised()
boolean	isReflexive(ObjectRoleExpression R)
boolean	isSameIndividuals(IndividualExpression I, IndividualExpression J)
boolean	isSatisfiable(ConceptExpression C)
boolean	isSubChain(ObjectRoleComplexExpression R, List<ObjectRoleExpression> l)
boolean	isSubRoles(RoleExpression R, RoleExpression S)
boolean	isSubsumedBy(ConceptExpression C, ConceptExpression D)
boolean	isSymmetric(ObjectRoleExpression R)
boolean	isTransitive(ObjectRoleExpression R)
void	needTracing() set need tracing to true
void	realiseKB() ensure that KB is realised
void	setIgnoreExprCache(boolean value) choose whether TExpr cache should be ignored
void	setInterruptedSwitch(AtomicBoolean b)
void	setSignature(TSignature sig) set the signature of the expression translator
void	setupSig(NamedEntity entity, List<AxiomInterface> Module) setup Name2Sig for a given entity;
void	writeReasoningResult(long time) dump query processing TIME, reasoning statistics and a (preprocessed) TBox

Methods inherited from class java.lang.Object

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

Constructor Detail

ReasoningKernel

public ReasoningKernel(JFactReasonerConfiguration conf,
               DatatypeFactory factory)

Parameters:

conf - conf

factory - factory

Method Detail

setInterruptedSwitch

@Original
public void setInterruptedSwitch(AtomicBoolean b)

Parameters:

b - b

setIgnoreExprCache

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

choose whether TExpr cache should be ignored

Parameters:

value - value

e

@PortedFrom(file="Kernel.h",
            name="e")
public DLTree e(Expression expr)

Parameters:

expr - expr

Returns:

get DLTree corresponding to an expression EXPR

needTracing

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

set need tracing to true

getTrace

@PortedFrom(file="Kernel.h",
            name="getTrace")
public List<AxiomInterface> 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

Parameters:

sig - sig

getOntology

@PortedFrom(file="Kernel.h",
            name="getOntology")
public Ontology getOntology()

Returns:

the ontology

getModExtractor

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

Parameters:

useSemantic - useSemantic

Returns:

module extractor

getModule

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

Parameters:

signature - signature

useSemantic - useSemantic

type - type

Returns:

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

getNonLocal

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

Parameters:

signature - signature

useSemantic - useSemantic

type - type

Returns:

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

getTBox

@PortedFrom(file="Kernel.h",
            name="getTBox")
public TBox getTBox()

Returns:

get RW access to TBox

getOptions

@PortedFrom(file="Kernel.h",
            name="getOptions")
public JFactReasonerConfiguration getOptions()

Returns:

kernel configuration

isKBPreprocessed

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

Returns:

classification status of KB

isKBClassified

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

Returns:

classification status of KB

isKBRealised

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

Returns:

realistion status of KB

writeReasoningResult

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

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

Parameters:

time - time

getExpressionManager

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

Returns:

expression manager

clearKB

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

reset current KB

Returns:

true if no new tbox is created

isKBConsistent

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

Returns:

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)

Parameters:

R - R

Returns:

true iff object role is functional

isFunctional

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

Parameters:

R - R

Returns:

true iff data role is functional

isInverseFunctional

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

Parameters:

R - R

Returns:

true iff role is inverse-functional

isTransitive

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

Parameters:

R - R

Returns:

true iff role is transitive

isSymmetric

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

Parameters:

R - R

Returns:

true iff role is symmetric

isAsymmetric

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

Parameters:

R - R

Returns:

true iff role is asymmetric

isReflexive

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

Parameters:

R - R

Returns:

true iff role is reflexive

isIrreflexive

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

Parameters:

R - R

Returns:

true iff role is irreflexive

isDisjointRoles

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

Parameters:

l - l

Returns:

true if disjoint

isDisjointRoles

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

Parameters:

R - R

S - S

Returns:

true iff two roles are disjoint

isDisjointRoles

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

Parameters:

R - R

S - S

Returns:

true iff two roles are disjoint

isSubRoles

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

Parameters:

R - R

S - S

Returns:

true if R is a sub-role of S

isSatisfiable

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

Parameters:

C - C

Returns:

true iff C is satisfiable

isSubsumedBy

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

Parameters:

C - C

D - D

Returns:

true iff C [= D holds

isDisjoint

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

Parameters:

C - C

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

Parameters:

C - C

D - D

Returns:

true iff C is equivalent to D

getConcepts

@PortedFrom(file="Kernel.h",
            name="getSupConcepts")
public <T extends Expression> TaxonomyActor<T> getConcepts(ConceptExpression C,
                                                                     boolean direct,
                                                                     TaxonomyActor<T> actor,
                                                                     boolean supDirection)

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

Type Parameters:

T - type

Parameters:

C - C

direct - direct

actor - actor

supDirection - true for superClasses, false for subclasses

Returns:

actor

getConcepts

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

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

Parameters:

C - C

direct - direct

actor - actor

supDirection - true for super direction

Returns:

actor

getEquivalentConcepts

@PortedFrom(file="Kernel.h",
            name="getEquivalentConcepts")
public <T extends Expression> TaxonomyActor<T> getEquivalentConcepts(ConceptExpression C,
                                                                               TaxonomyActor<T> actor)

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

Type Parameters:

T - type

Parameters:

C - C

actor - actor

Returns:

actor

getDisjointConcepts

@PortedFrom(file="Kernel.h",
            name="getDisjointConcepts")
public <T extends Expression> TaxonomyActor<T> getDisjointConcepts(ConceptExpression C,
                                                                             TaxonomyActor<T> actor)

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

Type Parameters:

T - type

Parameters:

C - C

actor - actor

Returns:

actor

getRoles

@PortedFrom(file="Kernel.h",
            name="getSupRoles")
public <T extends RoleExpression> TaxonomyActor<T> getRoles(RoleExpression r,
                                                                      boolean direct,
                                                                      TaxonomyActor<T> actor,
                                                                      boolean supDirection)

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

Type Parameters:

T - type

Parameters:

r - r

direct - direct

actor - actor

supDirection - true for super direction

Returns:

actor

getEquivalentRoles

@PortedFrom(file="Kernel.h",
            name="getEquivalentRoles")
public <T extends RoleExpression> TaxonomyActor<T> getEquivalentRoles(RoleExpression r,
                                                                                TaxonomyActor<T> actor)

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

Type Parameters:

T - type

Parameters:

r - r

actor - actor

Returns:

actor

getORoleDomain

@PortedFrom(file="Kernel.h",
            name="getORoleDomain")
public <T extends ConceptExpression> TaxonomyActor<T> getORoleDomain(ObjectRoleExpression r,
                                                                               boolean direct,
                                                                               TaxonomyActor<T> actor)

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

Type Parameters:

T - type

Parameters:

r - r

direct - direct

actor - actor

Returns:

modified actor

getDRoleDomain

@PortedFrom(file="Kernel.h",
            name="getDRoleDomain")
public <T extends ConceptExpression> TaxonomyActor<T> getDRoleDomain(DataRoleExpression r,
                                                                               boolean direct,
                                                                               TaxonomyActor<T> actor)

apply actor::apply() to all DIRECT NC that are in the domain of data role R

Type Parameters:

T - type

Parameters:

r - r

direct - direct

actor - actor

Returns:

modified actor

getInstances

@PortedFrom(file="Kernel.h",
            name="getInstances")
public TaxonomyActor<IndividualExpression> getInstances(ConceptExpression C,
                                                                  TaxonomyActor<IndividualExpression> actor,
                                                                  boolean direct)

Parameters:

C - C

actor - actor

direct - direct

Returns:

actor

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

Parameters:

C - C

actor - actor

getInstances

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

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

Parameters:

C - C

actor - actor

getTypes

@PortedFrom(file="Kernel.h",
            name="getTypes")
public <T extends Expression> TaxonomyActor<T> getTypes(IndividualName I,
                                                                  boolean direct,
                                                                  TaxonomyActor<T> actor)

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

Type Parameters:

T - type

Parameters:

I - I

direct - direct

actor - actor

Returns:

actor

getSameAs

@PortedFrom(file="Kernel.h",
            name="getSameAs")
public <T extends Expression> TaxonomyActor<T> getSameAs(IndividualName I,
                                                                   TaxonomyActor<T> actor)

apply actor__apply() to all synonyms of an individual I

Type Parameters:

T - type

Parameters:

I - I

actor - actor

Returns:

actor

isSameIndividuals

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

Parameters:

I - I

J - J

Returns:

true iff I and J refer to the same individual

buildCompletionTree

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

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

Parameters:

C - C

Returns:

the root node

getDataRoles

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

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

Parameters:

node - node

onlyDet - onlyDet

Returns:

set of data roles

getObjectRoles

@PortedFrom(file="Kernel.h",
            name="getObjectRoles")
public Set<ObjectRoleExpression> 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

Parameters:

node - node

onlyDet - onlyDet

needIncoming - needIncoming

Returns:

set of object roles

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

Parameters:

node - node

role - role

Returns:

neighbors for KE

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

Parameters:

node - node

onlyDet - onlyDet

Returns:

object labels for KE

getDataLabel

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

Parameters:

node - node

onlyDet - onlyDet

Returns:

data labels for KE

getBlocker

@PortedFrom(file="Kernel.h",
            name="getBlocker")
@Nonnull
public DlCompletionTree getBlocker(DlCompletionTree node)

Parameters:

node - node

Returns:

blocker of a blocked node NODE or NULL if node is not blocked

isInstance

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

Parameters:

I - I

C - C

Returns:

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

doIncremental

@PortedFrom(file="Incremental.cpp",
            name="doIncremental")
public void doIncremental()

incrementally classify changes

setupSig

@PortedFrom(file="Incremental.cpp",
            name="setupSig")
public void setupSig(NamedEntity entity,
                               List<AxiomInterface> Module)

setup Name2Sig for a given entity;

Parameters:

entity - entity

Module - Module

buildSignature

@PortedFrom(file="Incremental.cpp",
            name="buildSignature")
public void buildSignature(NamedEntity entity,
                                     List<AxiomInterface> Module,
                                     Set<NamedEntity> toProcess)

build signature for ENTITY and all dependent entities from toProcess; look for modules in Module;

Parameters:

entity - entity

Module - Module

toProcess - toProcess

initIncremental

@PortedFrom(file="Incremental.cpp",
            name="initIncremental")
public void initIncremental()

initialise the incremental bits on full reload

getDataRelatedIndividuals

@PortedFrom(file="Kernel.cpp",
            name="getDataRelatedIndividuals")
public Collection<IndividualName> getDataRelatedIndividuals(RoleExpression R,
                                                                      RoleExpression S,
                                                                      int op,
                                                                      Collection<IndividualExpression> individuals)

set RESULT into set of instances of A such that they do have data roles R and S

Parameters:

R - R

S - S

op - op

individuals - individuals

Returns:

related individuals

getAtomicDecompositionSize

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

create new atomic decomposition of the loaded ontology using TYPE.

Parameters:

useSemantics - useSemantics

type - type

Returns:

size of the AD

getAtomAxioms

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

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

Parameters:

index - index

Returns:

list of axioms for atom

getTautologies

@Original
public List<AxiomInterface> getTautologies()

Returns:

list of tautologies

getAtomModule

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

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

Parameters:

index - index

Returns:

module for atom

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

Parameters:

index - index

Returns:

dependent atoms for atom

getLocCheckNumber

@PortedFrom(file="Kernel.cpp",
            name="getLocCheckNumber")
public long getLocCheckNumber()

Returns:

a number of locality checks performed for creating an AD

isSubChain

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

Parameters:

R - R

l - l

Returns:

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

getRoleFillers

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

Parameters:

I - I

R - R

Returns:

individual role fillers for object role and individual