package org.semanticweb.HermiT.tableau;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import org.semanticweb.HermiT.blocking.AnywhereValidatedBlocking;
import org.semanticweb.HermiT.blocking.BlockingStrategy;
import org.semanticweb.HermiT.blocking.BlockingValidator;
import org.semanticweb.HermiT.blocking.DirectBlockingChecker;
import org.semanticweb.HermiT.blocking.ValidatedSingleDirectBlockingChecker;
import org.semanticweb.HermiT.existentials.CreationOrderStrategy;
import org.semanticweb.HermiT.existentials.ExistentialExpansionStrategy;
import org.semanticweb.HermiT.model.AnnotatedEquality;
import org.semanticweb.HermiT.model.AtLeastConcept;
import org.semanticweb.HermiT.model.Atom;
import org.semanticweb.HermiT.model.AtomicConcept;
import org.semanticweb.HermiT.model.AtomicRole;
import org.semanticweb.HermiT.model.Concept;
import org.semanticweb.HermiT.model.DLClause;
import org.semanticweb.HermiT.model.DLOntology;
import org.semanticweb.HermiT.model.InverseRole;
import org.semanticweb.HermiT.model.Variable;
public class BlockingValidatorTest extends AbstractReasonerInternalsTest {
protected final AtomicConcept A=AtomicConcept.create("A");
protected final AtomicConcept B=AtomicConcept.create("B");
protected final AtomicConcept C=AtomicConcept.create("C");
protected final AtomicConcept D=AtomicConcept.create("D");
protected final AtomicConcept E=AtomicConcept.create("E");
protected final AtomicRole R=AtomicRole.create("R");
protected final InverseRole INVR=InverseRole.create(R);
protected final AtomicRole S=AtomicRole.create("S");
protected final AtomicRole T=AtomicRole.create("T");
protected final AtLeastConcept ATLEAST2RA=AtLeastConcept.create(2,R,A);
protected final AtLeastConcept ATLEAST2TA=AtLeastConcept.create(2,T,A);
protected final AtLeastConcept ATLEAST2TD=AtLeastConcept.create(2,T,D);
protected final AtLeastConcept ATLEAST2INVRB=AtLeastConcept.create(2,INVR,B);
protected final AtLeastConcept ATLEAST1INVRE=AtLeastConcept.create(1,INVR,E);
protected final AtLeastConcept ATLEAST1SA=AtLeastConcept.create(1,S,A);
protected final AtLeastConcept ATLEAST1SB=AtLeastConcept.create(1,S,B);
protected final AtLeastConcept ATLEAST1RC=AtLeastConcept.create(1,R,C);
protected final AtLeastConcept ATLEAST1TD=AtLeastConcept.create(1,T,D);
protected final AtLeastConcept ATLEAST1INVRB=AtLeastConcept.create(1,INVR,B);
protected DLOntology TEST_DL_ONTOLOGY;
protected final Variable X=Variable.create("X");
protected final Variable Y=Variable.create("Y");
protected final Variable Y1=Variable.create("Y1");
protected final Variable Y2=Variable.create("Y2");
protected Tableau m_tableau;
protected BlockingStrategy m_blockingStrategy;
protected ExtensionManager m_extensionManager;
public BlockingValidatorTest(String name) {
super(name);
}
public void testOneInvalidBlock() {
Set<DLClause> dlClauses=new HashSet<DLClause>();
DLClause cl=DLClause.create(new Atom[] { Atom.create(ATLEAST2RA,X) }, new Atom[] { Atom.create(B,X) });
dlClauses.add(cl);
cl=DLClause.create(new Atom[] { Atom.create(ATLEAST2INVRB,X) }, new Atom[] { Atom.create(A,X) });
dlClauses.add(cl);
cl=DLClause.create(new Atom[] { Atom.create(ATLEAST1SA,X) }, new Atom[] { Atom.create(C,X) });
dlClauses.add(cl);
cl=DLClause.create(new Atom[] { Atom.create(ATLEAST2RA,X) }, new Atom[] { Atom.create(C,X) });
dlClauses.add(cl);
cl=DLClause.create(new Atom[] { Atom.create(ATLEAST1INVRE,X) }, new Atom[] { Atom.create(D,X) });
dlClauses.add(cl);
cl=DLClause.create(new Atom[] { Atom.create(B,X) }, new Atom[] { Atom.create(E,X) });
dlClauses.add(cl);
cl=DLClause.create(new Atom[] { Atom.create(D,X) }, new Atom[] { Atom.create(R,Y,X), Atom.create(B,Y) });
dlClauses.add(cl);
// [Y1 == Y2]@atMost(1 <r> <D>)(X) :- <r>(X,Y1), <D>(Y1), <r>(X,Y2), <D>(Y2), <C>(X)
cl=DLClause.create(new Atom[] { Atom.create(AnnotatedEquality.create(1, R, D),Y1,Y2,X) }, new Atom[] { Atom.create(C,X),Atom.create(R,X,Y1),Atom.create(D,Y1),Atom.create(R,X,Y2),Atom.create(D,Y2) });
dlClauses.add(cl);
TEST_DL_ONTOLOGY=getTestDLOntology(dlClauses);
DirectBlockingChecker directBlockingChecker=new ValidatedSingleDirectBlockingChecker(TEST_DL_ONTOLOGY.hasInverseRoles());
m_blockingStrategy=new AnywhereValidatedBlocking(directBlockingChecker,true,true);
ExistentialExpansionStrategy ExpansionStrategy=new CreationOrderStrategy(m_blockingStrategy);
m_tableau=new Tableau(new InterruptFlag(-1),null,ExpansionStrategy,false,TEST_DL_ONTOLOGY,null,new HashMap<String,Object>());
m_extensionManager=m_tableau.getExtensionManager();
DependencySet emptySet=m_tableau.getDependencySetFactory().emptySet();
Node a=m_tableau.createNewNINode(emptySet); // 1
Node b=m_tableau.createNewNINode(emptySet); // 2
Node a1=m_tableau.createNewTreeNode(emptySet,a); // 3
Node a2=m_tableau.createNewTreeNode(emptySet,a); // 4
Node a11=m_tableau.createNewTreeNode(emptySet,a1); // 5
Node a111=m_tableau.createNewTreeNode(emptySet,a11); // 6
Node b1=m_tableau.createNewTreeNode(emptySet,b); // 7
Node b2=m_tableau.createNewTreeNode(emptySet,b); // 8
Node b3=m_tableau.createNewTreeNode(emptySet,b); // 9
Node a12=m_tableau.createNewTreeNode(emptySet,a1); //10
Node a121=m_tableau.createNewTreeNode(emptySet,a12); //11
m_extensionManager.addAssertion(R,a,a1,emptySet,true);
m_extensionManager.addAssertion(R,a,a2,emptySet,true);
m_extensionManager.addAssertion(R,a11,a1,emptySet,true);
m_extensionManager.addAssertion(R,a11,a111,emptySet,true);
m_extensionManager.addAssertion(S,b,b1,emptySet,true);
m_extensionManager.addAssertion(R,b,b2,emptySet,true);
m_extensionManager.addAssertion(R,b,b3,emptySet,true);
m_extensionManager.addAssertion(R,a12,a1,emptySet,true);
m_extensionManager.addAssertion(R,a12,a121,emptySet,true);
m_extensionManager.addConceptAssertion(B,a,emptySet,true);
m_extensionManager.addConceptAssertion(ATLEAST2RA,a,emptySet,false);
m_extensionManager.addConceptAssertion(C,b,emptySet,true);
m_extensionManager.addConceptAssertion(ATLEAST1SA,b,emptySet,false);
m_extensionManager.addConceptAssertion(ATLEAST2RA,b,emptySet,false);
m_extensionManager.addConceptAssertion(A,a1,emptySet,true);
m_extensionManager.addConceptAssertion(ATLEAST2INVRB,a1,emptySet,false);
m_extensionManager.addConceptAssertion(D,a1,emptySet,false);
m_extensionManager.addConceptAssertion(ATLEAST1INVRE,a1,emptySet,false);
m_extensionManager.addConceptAssertion(A,a2,emptySet,true);
m_extensionManager.addConceptAssertion(ATLEAST2INVRB,a2,emptySet,false);
m_extensionManager.addConceptAssertion(D,a2,emptySet,false);
m_extensionManager.addConceptAssertion(ATLEAST1INVRE,a2,emptySet,false);
m_extensionManager.addConceptAssertion(B,a11,emptySet,true);
m_extensionManager.addConceptAssertion(ATLEAST2RA,a11,emptySet,false);
m_extensionManager.addConceptAssertion(A,a111,emptySet,true);
m_extensionManager.addConceptAssertion(ATLEAST2INVRB,a111,emptySet,false);
m_extensionManager.addConceptAssertion(D,a111,emptySet,false);
m_extensionManager.addConceptAssertion(ATLEAST1INVRE,a111,emptySet,false);
m_extensionManager.addConceptAssertion(A,b1,emptySet,true);
m_extensionManager.addConceptAssertion(ATLEAST2INVRB,b1,emptySet,false);
m_extensionManager.addConceptAssertion(A,b2,emptySet,true);
m_extensionManager.addConceptAssertion(ATLEAST2INVRB,b2,emptySet,false);
m_extensionManager.addConceptAssertion(A,b3,emptySet,true);
m_extensionManager.addConceptAssertion(ATLEAST2INVRB,b3,emptySet,false);
m_extensionManager.addConceptAssertion(E,a12,emptySet,true);
m_extensionManager.addConceptAssertion(B,a12,emptySet,false);
m_extensionManager.addConceptAssertion(ATLEAST2RA,a12,emptySet,false);
m_extensionManager.addConceptAssertion(A,a121,emptySet,true);
m_extensionManager.addConceptAssertion(ATLEAST2INVRB,a121,emptySet,false);
m_extensionManager.addConceptAssertion(D,a121,emptySet,false);
m_extensionManager.addConceptAssertion(ATLEAST1INVRE,a121,emptySet,false);
assertFalse(m_extensionManager.containsClash());
m_blockingStrategy.computeBlocking(false);
assertTrue(a111.isDirectlyBlocked() && a111.getBlocker()==a1);
assertTrue(a2.isDirectlyBlocked() && a2.getBlocker()==a1);
assertTrue(b1.isDirectlyBlocked() && b1.getBlocker()==a1);
assertTrue(b2.isDirectlyBlocked() && b2.getBlocker()==a1);
assertTrue(b3.isDirectlyBlocked() && b3.getBlocker()==a1);
assertTrue(a121.isDirectlyBlocked() && a121.getBlocker()==a1);
assertFalse(a.isBlocked());
assertFalse(b.isBlocked());
assertFalse(a1.isBlocked());
assertFalse(a11.isBlocked());
assertFalse(a12.isBlocked());
BlockingValidator validator=new BlockingValidator(m_tableau,m_tableau.getPermanentDLOntology().getDLClauses());
assertTrue(validator.isBlockValid(a2));
assertTrue(validator.isBlockValid(a111));
assertTrue(validator.isBlockValid(b1));
assertTrue(validator.isBlockValid(b2)!=validator.isBlockValid(b3));
assertTrue(validator.isBlockValid(a121));
}
public void testInvalidBlockWithAnnotatedEqualities() {
Set<DLClause> dlClauses=new HashSet<DLClause>();
DLClause cl=DLClause.create(new Atom[] { Atom.create(ATLEAST1SB,X) }, new Atom[] { Atom.create(A,X) });
dlClauses.add(cl);
cl=DLClause.create(new Atom[] { Atom.create(ATLEAST1INVRB,X) }, new Atom[] { Atom.create(A,X) });
dlClauses.add(cl);
cl=DLClause.create(new Atom[] { Atom.create(ATLEAST1RC,X) }, new Atom[] { Atom.create(S,Y,X), Atom.create(A,Y) });
dlClauses.add(cl);
cl=DLClause.create(new Atom[] { Atom.create(ATLEAST1TD,X) }, new Atom[] { Atom.create(B,X) });
dlClauses.add(cl);
cl=DLClause.create(new Atom[] { Atom.create(ATLEAST1INVRB,X) }, new Atom[] { Atom.create(E,X) });
dlClauses.add(cl);
cl=DLClause.create(new Atom[] { Atom.create(C,X) }, new Atom[] { Atom.create(E,X) });
dlClauses.add(cl);
// B -> <= 1 r.C
// [Y1 == Y2]@atMost(1 <r> <C>)(X) :- <r>(X,Y1), <C>(Y1), <r>(X,Y2), <C>(Y2), <B>(X)
cl=DLClause.create(new Atom[] { Atom.create(AnnotatedEquality.create(1, R, C),Y1,Y2,X) }, new Atom[] { Atom.create(B,X),Atom.create(R,X,Y1),Atom.create(C,Y1),Atom.create(R,X,Y2),Atom.create(C,Y2) });
dlClauses.add(cl);
TEST_DL_ONTOLOGY=getTestDLOntology(dlClauses);
DirectBlockingChecker directBlockingChecker=new ValidatedSingleDirectBlockingChecker(TEST_DL_ONTOLOGY.hasInverseRoles());
m_blockingStrategy=new AnywhereValidatedBlocking(directBlockingChecker,true,true);
ExistentialExpansionStrategy ExpansionStrategy=new CreationOrderStrategy(m_blockingStrategy);
m_tableau=new Tableau(new InterruptFlag(-1),null,ExpansionStrategy,false,TEST_DL_ONTOLOGY,null,new HashMap<String,Object>());
m_extensionManager=m_tableau.getExtensionManager();
DependencySet emptySet=m_tableau.getDependencySetFactory().emptySet();
Node a=m_tableau.createNewNINode(emptySet); // 1
Node a1=m_tableau.createNewTreeNode(emptySet,a); // 2
Node a2=m_tableau.createNewTreeNode(emptySet,a); // 3
Node a11=m_tableau.createNewTreeNode(emptySet,a1); // 4
Node a12=m_tableau.createNewTreeNode(emptySet,a1); // 5
m_extensionManager.addAssertion(S,a,a1,emptySet,true);
m_extensionManager.addAssertion(R,a2,a,emptySet,true);
m_extensionManager.addAssertion(R,a1,a11,emptySet,true);
m_extensionManager.addAssertion(T,a1,a12,emptySet,true);
m_extensionManager.addConceptAssertion(A,a,emptySet,true);
m_extensionManager.addConceptAssertion(C,a,emptySet,false);
m_extensionManager.addConceptAssertion(ATLEAST1SB,a,emptySet,false);
m_extensionManager.addConceptAssertion(ATLEAST1INVRB,a,emptySet,false);
m_extensionManager.addConceptAssertion(B,a1,emptySet,true);
m_extensionManager.addConceptAssertion(ATLEAST1TD,a1,emptySet,false);
m_extensionManager.addConceptAssertion(B,a2,emptySet,true);
m_extensionManager.addConceptAssertion(ATLEAST1TD,a2,emptySet,false);
m_extensionManager.addConceptAssertion(C,a11,emptySet,true);
m_extensionManager.addConceptAssertion(D,a12,emptySet,true);
assertFalse(m_extensionManager.containsClash());
m_blockingStrategy.computeBlocking(false);
assertTrue(a2.isDirectlyBlocked() && a2.getBlocker()==a1);
assertFalse(a.isBlocked());
assertFalse(a1.isBlocked());
assertFalse(a11.isBlocked());
assertFalse(a12.isBlocked());
BlockingValidator validator=new BlockingValidator(m_tableau,m_tableau.getPermanentDLOntology().getDLClauses());
assertFalse(validator.isBlockValid(a2));
}
protected void assertLabel(Node node,Concept... expected) {
assertLabel(m_tableau,node,expected);
}
}