return result;
}
public Bool isMergable(KnowledgeBase kb, CachedNode root1, CachedNode root2) {
Bool result = checkTrivialClash( root1, root2 );
if( result != null )
return result.not();
CachedNode roots[] = new CachedNode[] { root1, root2 };
boolean isIndependent = root1.isIndependent() && root2.isIndependent();
int root = roots[0].getDepends().size() < roots[1].getDepends().size()
? 0
: 1;
int otherRoot = 1 - root;
for( Entry<ATermAppl, DependencySet> entry : roots[root].getDepends().entrySet() ) {
ATermAppl c = entry.getKey();
ATermAppl notC = ATermUtils.negate( c );
DependencySet ds2 = roots[otherRoot].getDepends().get( notC );
if( ds2 != null ) {
DependencySet ds1 = entry.getValue();
boolean allIndependent = isIndependent && ds1.isIndependent() && ds2.isIndependent();
if( allIndependent ) {
if( log.isLoggable( Level.FINE ) )
log.fine( roots[root] + " has " + c + " " + roots[otherRoot]
+ " has negation " + ds1.max() + " " + ds2.max() );
return Bool.FALSE;
}
else {
if( log.isLoggable( Level.FINE ) )
log.fine( roots[root] + " has " + c + " " + roots[otherRoot]
+ " has negation " + ds1.max() + " " + ds2.max() );
result = Bool.UNKNOWN;
}
}
}
// if there is a suspicion there is no way to fix it later so return now
if( result != null )
return result;
for( root = 0; root < 2; root++ ) {
otherRoot = 1 - root;
for( ATermAppl c : roots[root].getDepends().keySet() ) {
if( ATermUtils.isPrimitive( c ) ) {
result = checkBinaryClash( kb, c, roots[root], roots[otherRoot] );
}
else if( ATermUtils.isAllValues( c ) ) {
result = checkAllValuesClash( kb, c, roots[root], roots[otherRoot] );
}
else if( ATermUtils.isNot( c ) ) {
ATermAppl arg = (ATermAppl) c.getArgument( 0 );
if( ATermUtils.isMin( arg ) ) {
result = checkMaxClash( kb, c, roots[root], roots[otherRoot] );
}
else if( ATermUtils.isSelf( arg ) ) {
result = checkSelfClash( kb, arg, roots[root], roots[otherRoot] );
}
}
if( result != null )
return result;
}
}
boolean bothNamedIndividuals = (root1 instanceof Individual && root2 instanceof Individual);
if( kb.getExpressivity().hasFunctionality() || kb.getExpressivity().hasFunctionalityD() ) {
root = (roots[0].getOutEdges().size() + roots[0].getInEdges().size()) < (roots[1]
.getOutEdges().size() + roots[1].getInEdges().size())
? 0
: 1;
otherRoot = 1 - root;
if( bothNamedIndividuals )
result = checkFunctionalityClashWithDifferents( (Individual) roots[root],
(Individual) roots[otherRoot] );
else
result = checkFunctionalityClash( roots[root], roots[otherRoot] );
if( result != null )
return result;
}
if( bothNamedIndividuals ) {
Individual ind1 = (Individual) root1;
Individual ind2 = (Individual) root2;
DependencySet ds = ind1.getDifferenceDependency( ind2 );
if( ds != null ) {
return ds.isIndependent()
? Bool.FALSE
: Bool.UNKNOWN;
}
for (Edge edge : ind1.getOutEdges()) {
if (edge.getRole().isIrreflexive() && edge.getTo().equals(ind2)) {
return edge.getDepends().isIndependent()
? Bool.FALSE
: Bool.UNKNOWN;
}
}
for (Edge edge : ind1.getInEdges()) {
if (edge.getRole().isIrreflexive() && edge.getFrom().equals(ind2)) {
return edge.getDepends().isIndependent()
? Bool.FALSE
: Bool.UNKNOWN;
}
}
}
if( kb.getExpressivity().hasDisjointRoles() ) {
Bool clash = checkDisjointPropertyClash( root1, root2 );
if (clash != null ) {
if( log.isLoggable( Level.FINE ) )
log.fine( "Cannot determine if two named individuals can be merged or not: " + roots[0] + " + roots[1]" );
return Bool.UNKNOWN;
}