uk.ac.manchester.cs.jfact.helpers

Class DLTreeFactory

java.lang.Object

uk.ac.manchester.cs.jfact.helpers.DLTreeFactory

All Implemented Interfaces:

Serializable

public class DLTreeFactory
extends Object
implements Serializable

dl tree factory

See Also:

Serialized Form

Method Summary

Modifier and Type	Method and Description
static DLTree	buildDisjAux(List<DLTree> arguments)
static DLTree	buildTree(Lexeme t)
static DLTree	buildTree(Lexeme t, Collection<DLTree> l)
static DLTree	buildTree(Lexeme t, DLTree t1)
static DLTree	buildTree(Lexeme t, DLTree t1, DLTree t2)
static boolean	containsC(DLTree c, DLTree d)
static DLTree	createBottom()
static DLTree	createEntry(Token tag, NamedEntry entry)
static DLTree	createInverse(DLTree r)
static DLTree	createRole(Role r)
static DLTree	createSNFAnd(Collection<DLTree> collection)
static DLTree	createSNFAnd(Collection<DLTree> collection, DLTree ancestor)
static DLTree	createSNFAnd(DLTree c, DLTree d)
static DLTree	createSNFExists(DLTree r, DLTree c) create existential restriction of given formulas (\ER.C)
static DLTree	createSNFForall(DLTree r, DLTree c)
static DLTree	createSNFGE(int n, DLTree r, DLTree c)
static DLTree	createSNFLE(int n, DLTree r, DLTree c) create at-most (LE) restriction of given formulas (max n R.C)
static DLTree	createSNFNot(DLTree c)
static DLTree	createSNFNot(DLTree c, DLTree ancestor)
static DLTree	createSNFOr(Collection<DLTree> c) create disjunction of given formulas
static DLTree	createSNFReducedAnd(DLTree c, DLTree d)
static DLTree	createSNFSelf(DLTree r) create SELF restriction for role R
static DLTree	createTop()
static DLTree	inverseComposition(DLTree tree)
static boolean	isBotRole(DLTree t) check whether T is a bottom (empty) role
static boolean	isDataRangeBigEnough(DLTree dr, int n)
static boolean	isFunctionalExpr(DLTree t, NamedEntry r) check whether T is an expression in the form (atmost 1 RNAME)
static boolean	isSemanticallyDataBottom(DLTree dr)
static boolean	isSemanticallyDataTop(DLTree dr)
static boolean	isSNF(DLTree t)
static boolean	isSubTree(DLTree t1, DLTree t2)
static boolean	isTopRole(DLTree t) check whether T is a top (universal) role
static boolean	isUniversalRole(DLTree t) check whether T is U-Role
static boolean	replaceSynonymsFromTree(DLTree desc)
static DLTree	simplifyDataTopForall(DLTree dr) simplify universal restriction with top data role
static DLTree	simplifyDataTopLE(int n, DLTree dr) simplify minimal cardinality restriction with top data role
static NamedEntry	unwrap(DLTree t) get TDE by a given DLTree
static DLTree	wrap(NamedEntry t) get DLTree by a given TDE

Methods inherited from class java.lang.Object

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

Method Detail

createBottom

public static DLTree createBottom()

Returns:

BOTTOM element

createInverse

public static DLTree createInverse(DLTree r)

Parameters:

r - R

Returns:

inverse

isSemanticallyDataTop

public static boolean isSemanticallyDataTop(DLTree dr)

Parameters:

dr - dr

Returns:

true iff a data range DR is semantically equivalent to TOP. FIXME!! good approximation for now

isSemanticallyDataBottom

public static boolean isSemanticallyDataBottom(DLTree dr)

Parameters:

dr - dr

Returns:

true iff a data range DR is semantically equivalent to BOTTOM. FIXME!! good approximation for now

isDataRangeBigEnough

public static boolean isDataRangeBigEnough(DLTree dr,
                                           int n)

Parameters:

dr - dr

n - n

Returns:

true iff the cardinality of a given data range DR is greater than N. FIXME!! good approximation for now

simplifyDataTopForall

public static DLTree simplifyDataTopForall(DLTree dr)

simplify universal restriction with top data role

Parameters:

dr - dr

Returns:

simplified tree

simplifyDataTopLE

public static DLTree simplifyDataTopLE(int n,
                                       DLTree dr)

simplify minimal cardinality restriction with top data role

Parameters:

n - n

dr - dr

Returns:

simplified tree

buildDisjAux

public static DLTree buildDisjAux(List<DLTree> arguments)

Parameters:

arguments - arguments to AND

Returns:

a construction in the form AND (\neg q_i)

createSNFAnd

public static DLTree createSNFAnd(@Nullable
                                  DLTree c,
                                  @Nullable
                                  DLTree d)

Parameters:

c - C

d - D

Returns:

and

createSNFAnd

public static DLTree createSNFAnd(Collection<DLTree> collection)

Parameters:

collection - collection

Returns:

and

createSNFAnd

public static DLTree createSNFAnd(Collection<DLTree> collection,
                                  DLTree ancestor)

Parameters:

collection - collection

ancestor - ancestor

Returns:

and

containsC

public static boolean containsC(DLTree c,
                                DLTree d)

Parameters:

c - tree to check

d - contained tree

Returns:

true if C contains D

createSNFReducedAnd

public static DLTree createSNFReducedAnd(@Nullable
                                         DLTree c,
                                         @Nullable
                                         DLTree d)

Parameters:

c - c

d - d

Returns:

C and D

createSNFExists

public static DLTree createSNFExists(DLTree r,
                                     DLTree c)

create existential restriction of given formulas (\ER.C)

Parameters:

r - R

c - C

Returns:

exist R C

createSNFForall

public static DLTree createSNFForall(DLTree r,
                                     DLTree c)

Parameters:

r - R

c - C

Returns:

for all

createRole

public static DLTree createRole(Role r)

Parameters:

r - R

Returns:

role

createEntry

public static DLTree createEntry(Token tag,
                                 NamedEntry entry)

Parameters:

tag - tag

entry - entry

Returns:

entry

createSNFLE

public static DLTree createSNFLE(int n,
                                 DLTree r,
                                 DLTree c)

create at-most (LE) restriction of given formulas (max n R.C)

Parameters:

n - n

r - R

c - C

Returns:

at most

isBotRole

public static boolean isBotRole(DLTree t)

check whether T is a bottom (empty) role

Parameters:

t - tree

Returns:

true if bottom

isTopRole

public static boolean isTopRole(DLTree t)

check whether T is a top (universal) role

Parameters:

t - tree

Returns:

true if top role

createSNFSelf

public static DLTree createSNFSelf(DLTree r)

create SELF restriction for role R

Parameters:

r - R

Returns:

self

createSNFGE

public static DLTree createSNFGE(int n,
                                 DLTree r,
                                 DLTree c)

Parameters:

n - n

r - R

c - C

Returns:

at least

createSNFNot

public static DLTree createSNFNot(DLTree c)

Parameters:

c - C

Returns:

not

createSNFNot

public static DLTree createSNFNot(DLTree c,
                                  DLTree ancestor)

Parameters:

c - C

ancestor - ancestor

Returns:

not

createSNFOr

public static DLTree createSNFOr(Collection<DLTree> c)

create disjunction of given formulas

Parameters:

c - C

Returns:

OR C

createTop

public static DLTree createTop()

Returns:

TOP element

inverseComposition

public static DLTree inverseComposition(DLTree tree)

Parameters:

tree - tree

Returns:

inverse

wrap

public static DLTree wrap(NamedEntry t)

get DLTree by a given TDE

Parameters:

t - t

Returns:

wrapped entry

unwrap

public static NamedEntry unwrap(DLTree t)

get TDE by a given DLTree

Parameters:

t - t

Returns:

unwrapped entry

buildTree

public static DLTree buildTree(Lexeme t,
                               DLTree t1,
                               DLTree t2)

Parameters:

t - t

t1 - t1

t2 - t2

Returns:

tree with two children

buildTree

public static DLTree buildTree(Lexeme t,
                               Collection<DLTree> l)

Parameters:

t - t

l - list

Returns:

tree with multiple children

buildTree

public static DLTree buildTree(Lexeme t,
                               DLTree t1)

Parameters:

t - t

t1 - t1

Returns:

single child tree

buildTree

public static DLTree buildTree(Lexeme t)

Parameters:

t - t

Returns:

leaf tree

isFunctionalExpr

public static boolean isFunctionalExpr(@Nullable
                                       DLTree t,
                                       NamedEntry r)

check whether T is an expression in the form (atmost 1 RNAME)

Parameters:

t - t

r - R

Returns:

true if functional

isSNF

public static boolean isSNF(@Nullable
                            DLTree t)

Parameters:

t - t

Returns:

true is SNF

isSubTree

public static boolean isSubTree(@Nullable
                                DLTree t1,
                                @Nullable
                                DLTree t2)

Parameters:

t1 - t1

t2 - t2

Returns:

true if t2 is a subtree

isUniversalRole

public static boolean isUniversalRole(DLTree t)

check whether T is U-Role

Parameters:

t - t

Returns:

true if universal

replaceSynonymsFromTree

public static boolean replaceSynonymsFromTree(@Nullable
                                              DLTree desc)

Parameters:

desc - desc

Returns:

true if changes happen