protected void refillInferred() {
   getOWLModelManager()
       .getReasonerPreferences()
       .executeTask(
           OptionalInferenceTask.SHOW_INFERRED_EQUIVALENT_OBJECT_PROPERTIES,
           () -> {
             if (!getOWLModelManager().getReasoner().isConsistent()) {
               return;
             }
             Node<OWLObjectPropertyExpression> equivalentObjectProperties =
                 getReasoner().getEquivalentObjectProperties(getRootObject());
             if (!equivalentObjectProperties.getEntitiesMinus(getRootObject()).isEmpty()) {
               OWLEquivalentObjectPropertiesAxiom ax =
                   getOWLDataFactory()
                       .getOWLEquivalentObjectPropertiesAxiom(
                           equivalentObjectProperties.getEntities());
               if (!added.contains(ax)) {
                 addInferredRowIfNontrivial(
                     new OWLEquivalentObjectPropertiesAxiomFrameSectionRow(
                         getOWLEditorKit(),
                         OWLEquivalentObjectPropertiesAxiomFrameSection.this,
                         null,
                         getRootObject(),
                         ax));
               }
             }
           });
 }
 protected boolean isSuccessorRepresented(
     DomainNode<?> from, DomainNode<?> to, OWLObjectProperty property) {
   if (from.getId() instanceof OWLClassExpression && to.getId() instanceof OWLClassExpression) {
     Set<DomainNode<?>> successors = from.getSuccessors(property);
     //			StatStore.getInstance().enterValue("subclass accessing", 1.0);
     //			NodeSet<OWLClass> subClasses =
     // m_ontologyOperator.getReasoner().getSubClasses((OWLClass)to.getId(), false);
     NodeSet<OWLClass> subClasses = currentIdSubClasses;
     Node<OWLClass> eqClasses = currentIdEqClasses;
     for (DomainNode<?> succ : successors) {
       // only compare successors to other class domain elements
       if (succ.getId() instanceof OWLClass) {
         //					if(succ.getInstantiators().containsAll(to.getInstantiators())){ // could be done
         // with reasoner
         if (m_useBuffer) {
           if (m_subClassBuffer.get((OWLClass) to.getId()).contains((OWLClass) succ.getId())
               || m_equivalentClassBuffer
                   .get((OWLClass) to.getId())
                   .contains((OWLClass) succ.getId())) {
             return true;
           }
         } else {
           if (subClasses.containsEntity((OWLClass) succ.getId())
               || eqClasses.contains(
                   (OWLClass)
                       succ.getId())) { // if there exists a successors more (or equally) specific
             // than the new one
             return true;
           }
         }
       }
     }
   }
   return false;
 }
 public Set<OWLClass> getEquivalentClasses(String classExpressionString) {
   if (classExpressionString.trim().length() == 0) {
     return Collections.emptySet();
   }
   OWLClassExpression classExpression = parser.parseClassExpression(classExpressionString);
   Node<OWLClass> equivalentClasses = reasoner.getEquivalentClasses(classExpression);
   Set<OWLClass> result = null;
   if (classExpression.isAnonymous()) {
     result = equivalentClasses.getEntities();
   } else {
     result = equivalentClasses.getEntitiesMinus(classExpression.asOWLClass());
   }
   return result;
 }
Example #4
0
 private static void print(Node<OWLClass> parent, OWLReasoner reasoner, int depth) {
   // We don't want to print out the bottom node (containing owl:Nothing and unsatisfiable classes)
   // because this would appear as a leaf node everywhere
   if (parent.isBottomNode()) {
     return;
   }
   // Print an indent to denote parent-child relationships
   printIndent(depth);
   // Now print the node (containing the child classes)
   printNode(parent);
   for (Node<OWLClass> child : reasoner.getSubClasses(parent.getRepresentativeElement(), true)) {
     // Recurse to do the children.  Note that we don't have to worry about cycles as there
     // are non in the inferred class hierarchy graph - a cycle gets collapsed into a single
     // node since each class in the cycle is equivalent.
     print(child, reasoner, depth + 1);
   }
 }
Example #5
0
  /**
   * Adds Object Properties to the current Individual, and adds corresponding predicate to the list
   * (parallel arraylists)
   */
  public void addObjectPropertiesByPredicateType(String predicateURI, OWLNamedIndividual ind) {
    OWLObjectProperty objectProp =
        PROVGraph.manager.getOWLDataFactory().getOWLObjectProperty(IRI.create(predicateURI));
    NodeSet<OWLNamedIndividual> owlObjectIndividuals =
        PROVGraph.reasoner.getObjectPropertyValues(ind, objectProp);
    System.out.println(predicateURI + " Nodes: " + owlObjectIndividuals.getNodes().size());

    for (Node<OWLNamedIndividual> owlSameInd : owlObjectIndividuals) {
      OWLNamedIndividual currInd = owlSameInd.getRepresentativeElement();

      if (currInd != null) {
        String owlIndURI = currInd.toStringID();
        System.out.println("owlIndURI: " + owlIndURI);

        // if the target individual has been previously created, point to that PROVIndividual object
        if (PROVGraph.individualsHM.containsKey(owlIndURI)) {
          PROVIndividual targetProvInd =
              PROVGraph.individualsHM.get(owlSameInd.getRepresentativeElement().toStringID());

          OPconnectionObjectInds.add(targetProvInd);
          OPconnections.add(predicateURI);
        } else // otherwise create a new object with the URI, and add it to the pool of collected
               // PROVIndividuals
        {
          PROVIndividual targetProvInd =
              new PROVIndividual(owlSameInd.getRepresentativeElement().toStringID());
          PROVGraph.individualsHM.put(targetProvInd.uri, targetProvInd);

          OPconnectionObjectInds.add(targetProvInd);
          OPconnections.add(predicateURI);
        }
      } else {
        PROVIndividual anonProvInd = new PROVIndividual("Anonymous Individual " + (++anonIndsCntr));
        // **anonProvInd.uri not unique
        PROVGraph.individualsHM.put(anonProvInd.uri, anonProvInd);

        OPconnectionObjectInds.add(anonProvInd);
        OPconnections.add(predicateURI);
      }
    }
  }
Example #6
0
 private static void printNode(Node<OWLClass> node) {
   // Print out a node as a list of class names in curly brackets
   System.out.print("{");
   for (Iterator<OWLClass> it = node.getEntities().iterator(); it.hasNext(); ) {
     OWLClass cls = it.next();
     // User a prefix manager to provide a slightly nicer shorter name
     System.out.print(pm.getShortForm(cls));
     if (it.hasNext()) {
       System.out.print(" ");
     }
   }
   System.out.println("}");
 }
Example #7
0
  public static void main(String[] args) {

    try {
      // Create our ontology manager in the usual way.
      OWLOntologyManager manager = OWLManager.createOWLOntologyManager();

      // Load a copy of the people+pets ontology.  We'll load the ontology from the web (it's
      // acutally located
      // in the TONES ontology repository).
      IRI docIRI = IRI.create(DOCUMENT_IRI);
      // We load the ontology from a document - our IRI points to it directly
      OWLOntology ont = manager.loadOntologyFromOntologyDocument(docIRI);
      System.out.println("Loaded " + ont.getOntologyID());

      // We need to create an instance of OWLReasoner.  An OWLReasoner provides the basic
      // query functionality that we need, for example the ability obtain the subclasses
      // of a class etc.  To do this we use a reasoner factory.

      // Create a reasoner factory.  In this case, we will use HermiT, but we could also
      // use FaCT++ (http://code.google.com/p/factplusplus/) or
      // Pellet(http://clarkparsia.com/pellet)
      // Note that (as of 03 Feb 2010) FaCT++ and Pellet OWL API 3.0.0 compatible libraries are
      // expected to be available in the near future).

      // For now, we'll use HermiT
      // HermiT can be downloaded from http://hermit-reasoner.com
      // Make sure you get the HermiT library and add it to your class path.  You can then
      // instantiate the HermiT reasoner factory:
      // Comment out the first line below and uncomment the second line below to instantiate
      // the HermiT reasoner factory.  You'll also need to import the
      // org.semanticweb.HermiT.Reasoner
      // package.
      OWLReasonerFactory reasonerFactory = null;
      //            OWLReasonerFactory reasonerFactory = new Reasoner.ReasonerFactory();

      // We'll now create an instance of an OWLReasoner (the implementation being provided by HermiT
      // as
      // we're using the HermiT reasoner factory).  The are two categories of reasoner, Buffering
      // and
      // NonBuffering.  In our case, we'll create the buffering reasoner, which is the default kind
      // of reasoner.
      // We'll also attach a progress monitor to the reasoner.  To do this we set up a configuration
      // that
      // knows about a progress monitor.

      // Create a console progress monitor.  This will print the reasoner progress out to the
      // console.
      ConsoleProgressMonitor progressMonitor = new ConsoleProgressMonitor();
      // Specify the progress monitor via a configuration.  We could also specify other setup
      // parameters in
      // the configuration, and different reasoners may accept their own defined parameters this
      // way.
      OWLReasonerConfiguration config = new SimpleConfiguration(progressMonitor);
      // Create a reasoner that will reason over our ontology and its imports closure.  Pass in the
      // configuration.
      OWLReasoner reasoner = reasonerFactory.createReasoner(ont, config);

      // Ask the reasoner to do all the necessary work now
      reasoner.precomputeInferences();

      // We can determine if the ontology is actually consistent (in this case, it should be).
      boolean consistent = reasoner.isConsistent();
      System.out.println("Consistent: " + consistent);
      System.out.println("\n");

      // We can easily get a list of unsatisfiable classes.  (A class is unsatisfiable if it
      // can't possibly have any instances).  Note that the getUnsatisfiableClasses method
      // is really just a convenience method for obtaining the classes that are equivalent
      // to owl:Nothing.  In our case there should be just one unsatisfiable class - "mad_cow"
      // We ask the reasoner for the unsatisfiable classes, which returns the bottom node
      // in the class hierarchy (an unsatisfiable class is a subclass of every class).
      Node<OWLClass> bottomNode = reasoner.getUnsatisfiableClasses();
      // This node contains owl:Nothing and all the classes that are equivalent to owl:Nothing -
      // i.e. the unsatisfiable classes.
      // We just want to print out the unsatisfiable classes excluding owl:Nothing, and we can
      // used a convenience method on the node to get these
      Set<OWLClass> unsatisfiable = bottomNode.getEntitiesMinusBottom();
      if (!unsatisfiable.isEmpty()) {
        System.out.println("The following classes are unsatisfiable: ");
        for (OWLClass cls : unsatisfiable) {
          System.out.println("    " + cls);
        }
      } else {
        System.out.println("There are no unsatisfiable classes");
      }
      System.out.println("\n");

      // Now we want to query the reasoner for all descendants of vegetarian.  Vegetarians are
      // defined in the
      // ontology to be animals that don't eat animals or parts of animals.
      OWLDataFactory fac = manager.getOWLDataFactory();
      // Get a reference to the vegetarian class so that we can as the reasoner about it.
      // The full IRI of this class happens to be:
      // <http://owl.man.ac.uk/2005/07/sssw/people#vegetarian>
      OWLClass vegPizza =
          fac.getOWLClass(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#vegetarian"));

      // Now use the reasoner to obtain the subclasses of vegetarian.
      // We can ask for the direct subclasses of vegetarian or all of the (proper) subclasses of
      // vegetarian.
      // In this case we just want the direct ones (which we specify by the "true" flag).
      NodeSet<OWLClass> subClses = reasoner.getSubClasses(vegPizza, true);

      // The reasoner returns a NodeSet, which represents a set of Nodes.
      // Each node in the set represents a subclass of vegetarian pizza.  A node of classes contains
      // classes,
      // where each class in the node is equivalent. For example, if we asked for the
      // subclasses of some class A and got back a NodeSet containing two nodes {B, C} and {D}, then
      // A would have
      // two proper subclasses.  One of these subclasses would be equivalent to the class D, and the
      // other would
      // be the class that is equivalent to class B and class C.

      // In this case, we don't particularly care about the equivalences, so we will flatten this
      // set of sets and print the result
      Set<OWLClass> clses = subClses.getFlattened();
      System.out.println("Subclasses of vegetarian: ");
      for (OWLClass cls : clses) {
        System.out.println("    " + cls);
      }
      System.out.println("\n");

      // In this case, we should find that the classes, cow, sheep and giraffe are vegetarian.  Note
      // that in this
      // ontology only the class cow had been stated to be a subclass of vegetarian.  The fact that
      // sheep and
      // giraffe are subclasses of vegetarian was implicit in the ontology (through other things we
      // had said)
      // and this illustrates why it is important to use a reasoner for querying an ontology.

      // We can easily retrieve the instances of a class.  In this example we'll obtain the
      // instances of
      // the class pet.  This class has a full IRI of <http://owl.man.ac.uk/2005/07/sssw/people#pet>

      // We need to obtain a reference to this class so that we can ask the reasoner about it.
      OWLClass country =
          fac.getOWLClass(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#pet"));
      // Ask the reasoner for the instances of pet
      NodeSet<OWLNamedIndividual> individualsNodeSet = reasoner.getInstances(country, true);
      // The reasoner returns a NodeSet again.  This time the NodeSet contains individuals.
      // Again, we just want the individuals, so get a flattened set.
      Set<OWLNamedIndividual> individuals = individualsNodeSet.getFlattened();
      System.out.println("Instances of pet: ");
      for (OWLNamedIndividual ind : individuals) {
        System.out.println("    " + ind);
      }
      System.out.println("\n");

      // Again, it's worth noting that not all of the individuals that are returned were explicitly
      // stated
      // to be pets.

      // Finally, we can ask for the property values (property assertions in OWL speak) for a given
      // individual
      // and property.
      // Let's get the property values for the individual Mick, the full IRI of which is
      // <http://owl.man.ac.uk/2005/07/sssw/people#Mick>

      // Get a reference to the individual Mick
      OWLNamedIndividual mick =
          fac.getOWLNamedIndividual(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#Mick"));

      // Let's get the pets of Mick
      // Get hold of the has_pet property which has a full IRI of
      // <http://owl.man.ac.uk/2005/07/sssw/people#has_pet>
      OWLObjectProperty hasPet =
          fac.getOWLObjectProperty(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#has_pet"));

      // Now ask the reasoner for the has_pet property values for Mick
      NodeSet<OWLNamedIndividual> petValuesNodeSet = reasoner.getObjectPropertyValues(mick, hasPet);
      Set<OWLNamedIndividual> values = petValuesNodeSet.getFlattened();
      System.out.println("The has_pet property values for Mick are: ");
      for (OWLNamedIndividual ind : values) {
        System.out.println("    " + ind);
      }

      // Notice that Mick has a pet Rex, which wasn't asserted in the ontology.

      // Finally, let's print out the class hierarchy.
      // Get hold of the top node in the class hierarchy (containing owl:Thing)
      // Now print the hierarchy out
      Node<OWLClass> topNode = reasoner.getTopClassNode();
      print(topNode, reasoner, 0);

    } catch (UnsupportedOperationException exception) {
      System.out.println("Unsupported reasoner operation.");
    } catch (OWLOntologyCreationException e) {
      System.out.println("Could not load the pizza ontology: " + e.getMessage());
    }
  }
 @Test
 public void shouldGetBottomDataPropertyNode() {
   Node<OWLDataProperty> node = reasoner.getBottomDataPropertyNode();
   assertThat(node.getEntities(), is(Collections.singleton(owlBottomDataProperty)));
 }
 @Test
 public void shouldGetTopObjectPropertyNode() {
   Node<OWLObjectPropertyExpression> node = reasoner.getTopObjectPropertyNode();
   assertThat(node.getEntities(), is(Collections.singleton(owlTopObjectProperty)));
 }
 @Test
 public void shouldGetBottomClassNode() {
   Node<OWLClass> node = reasoner.getBottomClassNode();
   assertThat(node.getEntities(), is(Collections.singleton(owlNothing)));
 }
Example #11
0
 @Override
 public String getRenderName() {
   return CommandInterpreter.getRenderName(ticker.getRepresentativeElement());
 }