recherche en ontologie Classe EquivalentTo à partir de plusieurs classes simples

Question

Je joue avec l'ontologie Pizza, et j'essaie d'obtenir ce que j'ai compris comme une connaissance inférée. Avec quelques classes simples, j'aimerais obtenir le nom des autres classes qui les utilisent.

Pour être exact, dans l'ontologie Pizza nous pouvons trouver:

• alimentaire
• food/Pizza
• food/Pizza/CheeseyPizza (équivalent à Pizza and (hasTopping some CheeseTopping), Sous-classe de hasBase some PizzaBase)
• alimentaire/PizzaBase
• Alimentaire/PizzaBase/DeepPanBase
• Alimentaire/PizzaTopping
• alimentaire/PizzaTopping/MozzarellaTopping

Je suis en train d'écrire une requête SPARQL en utilisant MozzarellaTopping et DeepPanBase qui peuvent me donner le résultat CheeseyPizza ... mais je ne sais pas comment le faire, et je Je ne sais pas s'il est possible de le faire. (J'ai lu quelque part qu'il était possible de faire des inférences sur des individus, pas sur des classes (https://stackoverflow.com/questions/28396707/sparql-query-on-restriction-list-equivalent-to-in-protégé) ... mais Protégé semble faire des inférences sur le CheeseyPizza).

Pour l'instant, je viens de recevoir la liste commune des ancêtres (en utilisant des exemples Jena):

showQuery(model, prefix 
     + "SELECT ?o " 
     + "WHERE { " 
     + " pizza:MozzarellaTopping rdfs:subClassOf* ?o . " 
     + " pizza:DeepPanBase rdfs:subClassOf* ?o . " 
     + " FILTER (! isBlank(?o)) " + "} " 
     ); 

Y at-il une demande SPARQL pour obtenir des classes inférées, des classes individuelles, sans connaître la structure de l'ontologie? (Sans connaître la structure de l'ontologie: dans la requête des ancêtres, je mets juste le nom des deux classes, mais je n'ai jamais donné la structure Food/Pizza ... Je veux vraiment faire une vraie recherche dans toute l'ontologie avec tout Mozzarella et DeepPan)

Merci!

EDIT:

J'oublie de dire que je pense aussi à l'aide d'un raisonneur (je travaille sur Jena). Mais je ne sais pas si c'est la bonne façon de le faire.

Answer 1

J'ai utilisé beaucoup de documentation, et je pense que j'ai finalement trouvé la solution. Ce n'est pas exactement ce à quoi je m'attendais, mais pour l'instant ce sera suffisant. L'idée principale: créer des individus (qui sont des instances de concepts/classes), les lier ensemble, et demander à un raisonneur de découvrir des choses (inférences).

docs utiles (merci StakOverflow pour les liens):

https://jena.apache.org/documentation/inference/#owl

http://jena.apache.org/documentation/ontology/#instances-or-individuals

http://jena.apache.org/documentation/ontology/index.html

Tout d'abord, quelle est ma solution:

• instancier la base modèle (et charger l'ontologie pizza)
• instancier un modèle d'inférence (et choisir un raisonneur)
• créer dans le modèle de base: plusieurs personnes et propriétés/relations entre les
• validité de vérification du modèle, demandez affirmation (dans le modèle de base) et

Cela fonctionne. Je peux créer un "MozzarellaTopping" individuel, un "DeepPanBase" individuel et un "Food" individuel. J'ai ajouté deux propriétés à "Food": hasBase à DeepPanBase individuel, et hasTopping à MozzarellaTopping individuel.

Voici le code explique étape par étape (code complet à la fin):

instancier et modèle de base de la charge de pizza.owl.rdf

public static final String SOURCE  = "./resources/"; 
    public static final String PIZZA_NS = "http://www.co-ode.org/ontologies/pizza/pizza.owl#"; 

    public void run() 
    { 
     // Prefix/Header for SPARQL requests 
     final String prefix = "prefix pizza: <" + PIZZA_NS + ">\n" 
       + "prefix rdfs: <" + RDFS.getURI() + ">\n" + "prefix owl: <" 
       + OWL.getURI() + ">\n"; 
     // Prefix for classes, individuals, ... for every object 
     final String NS = PIZZA_NS; 

     System.out.println("CREATE THE BASE MODEL\n"); 
     // CREATE THE BASE MODEL 
     OntModel base = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM); 
     base.read(SOURCE + "pizza.owl.rdf", "RDF/XML"); 

Créer le modèle inférées:

System.out.println("CREATE THE REASONING MODEL USING THE BASE\n"); 
     // CREATE THE REASONING MODEL USING THE BASE 
     OntModel inf = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_MICRO_RULE_INF, base); 
     // OWL_MEM_MICRO_RULE_INF // It works + Very quick 
     // OWL_MEM_MINI_RULE_INF // It works + Slow (40Mins) + 1,1Go RAM (Validity is slow) 
     // OWL_MEM_RULE_INF // It works (mights loop if error) + VERY SLOW + 2,1 GO RAM (unfinished) 
     // OWL_MEM_TRANS_INF // It works (SPARQL mights not work) + Ultra Speed/No inference 

Obtenir des classes et propriétés utiles dans java pour les futurs individus instanciation:

 System.out.println("CREATE INDIVIDUALS FOR TESTING PURPOSE\n"); 
     // CREATE INDIVIDUALS FOR TESTING PURPOSE 

     // Instantiate each useful Class 
     OntClass ThingClass = base.getOntClass(NS + "owl:Thing"); 
     OntClass FoodClass = base.getOntClass(NS + "Food"); 
     OntClass IceCreamClass = base.getOntClass(NS + "IceCream"); 
     OntClass PizzaClass = base.getOntClass(NS + "Pizza"); 
     OntClass MozzaToppingClass = base.getOntClass(NS + "MozzarellaTopping"); 
     OntClass DeepPanBaseClass = base.getOntClass(NS + "DeepPanBase"); 

     // Instantiate each useful Property (relation) 
     OntProperty hasIngredientProperty = base.createObjectProperty(NS + "hasIngredient"); 
     OntProperty hasBaseProperty = base.createObjectProperty(NS + "hasBase"); 
     OntProperty hasToppingProperty = base.createObjectProperty(NS + "hasTopping"); 

     // Instantiate each useful individual 
     Individual MozzaTopping = base.createIndividual(NS + "MyMozzaTopping", MozzaToppingClass); 
     Individual DeepPanBase = base.createIndividual(NS + "MyDeepPanBase", DeepPanBaseClass); 

Ensuite, je vérifie d'abord un individu avec deux classes simultanées (MozzarellaTopping et DeepPanBase) ... raisonneur voir un CheeseyPizza, mais le rapport de validité ne fonctionne pas:

 /* 
     * BEGINNING OF THE TESTS HERE 
     */ 
     System.out.println("\nTEST VALIDITY BEFORE ADDING INDIVIDUALS\n"); 
     checkValidity(inf); 

     // Instantiate testing individuals 
     // MyPizza1 : individual with 2 classes simultaneously (Mozza & DeepPan) 
     Individual MyPizza1 = base.createIndividual(NS + "MyPizza1", ThingClass); 
     MyPizza1.setOntClass(MozzaToppingClass); 
     MyPizza1.addOntClass(DeepPanBaseClass); 

     System.out.println("\nTest MyPizza1\n"); 
     showAsserted(base, NS + "MyPizza1"); 
     showInferred(inf, NS + "MyPizza1"); 
     System.out.println("\nTest Validity of MyPizza1 : "); 
     checkValidity(inf); // ERROR 

     MyPizza1.remove(); 
     System.out.println("\nRemove MyPizza1, Validity should be OK now : "); 
     checkValidity(inf); // OK 

Ensuite, j'ai essayé "Food" (ou "Pizza") individu auquel j'ai eu une relation hasBase DeepPanBase, et une autre relation hasTopping MozzarellaTopping. Il travaille, problème ni en contrôle de validité:

 // MyPizza2 : individual of class "Food", linked with Mozza & DeepPan 
     Individual MyPizza2 = base.createIndividual(NS + "MyPizza2", FoodClass); 
     MyPizza2.addProperty(hasBaseProperty, DeepPanBase); 
     MyPizza2.addProperty(hasToppingProperty, MozzaTopping); 

     System.out.println("\nTest MyPizza2\n"); 
     showAsserted(base, NS + "MyPizza2"); 
     showInferred(inf, NS + "MyPizza2"); 
     System.out.println("\nTest Validity of MyPizza2 : "); 
     checkValidity(inf); // OK 

     MyPizza2.remove(); 
     System.out.println("\nRemove MyPizza2, Validity should be OK now : "); 
     checkValidity(inf); // OK 

Ensuite, j'essaie une personne DeepPanBase, auquel je donne une propriété/relation hasTopping MozzarellaTopping. Le raisonneur agit aussi comme vous pourriez le penser: il dit que c'est un CheeseyPizza, mais la vérification de validité dit que c'est faux. Enfin, un test avec un individu IceCream (Food) est réalisé. Je lui donne une relation hasBase DeepPanBase et une autre relation hasTopping MozzarellaTopping. Le raisonneur dit que c'est un CheeseyPizza, et la vérification de validité crier que c'est faux.

 // IceCream : individual of class "IceCream", linked with Moza & DeePan 
     Individual MyIceCream = base.createIndividual(NS + "MyIceCream", IceCreamClass); 
     MyIceCream.addProperty(hasBaseProperty, DeepPanBase); 
     MyIceCream.addProperty(hasToppingProperty, MozzaTopping); 

     System.out.println("\nTest IceCream\n"); 
     showAsserted(base, NS + "MyIceCream"); 
     showInferred(inf, NS + "MyIceCream"); 
     System.out.println("\nTest Validity of IceCream : "); 
     checkValidity(inf); 

Le vérificateur de validité a raison. Si vous vérifiez ce qu'est une pizza, vous verrez qu'il s'agit d'un «aliment» individuel qui contient des «ingrédients»/garnitures, et au moins un PizzaBase ... mais c'est aussi quelque chose qui n'est pas un PizzaTopping, PAS un PizzaBase, et PAS une glace. (c'est pourquoi le contrôle de validité pleure ...si je tente de mettre PizzaTopping sur un IceCream, il est impossible ...)

---

Quoi qu'il en soit, comme promis je donne le code complet ici:

/* 
    * Example of usage of reasoner with Java. Everything is coming from Apache JENA 
    * examples. I modified a lot of things for making my personal requests. 
    * Fabrice Boissier 
    */ 

    package Jena_Reasoner_Simple; 

    import java.util.Date; 
    import java.util.Iterator; 

    import org.apache.jena.ontology.Individual; 
    import org.apache.jena.ontology.OntClass; 
    import org.apache.jena.ontology.OntModel; 
    import org.apache.jena.ontology.OntModelSpec; 
    import org.apache.jena.ontology.OntProperty; 
    import org.apache.jena.rdf.model.ModelFactory; 
    import org.apache.jena.rdf.model.Resource; 
    import org.apache.jena.reasoner.ValidityReport; 
    import org.apache.jena.vocabulary.OWL; 
    import org.apache.jena.vocabulary.RDFS; 

    public class Simple_Reasoner_StepByStep 
    { 
    public static void main(String[] args) 
    { 
     System.out.println("BEGIN : " + new Date()); 
     new Simple_Reasoner_StepByStep().run(); 
     System.out.println("END : " + new Date()); 
    } 

    public static final String SOURCE  = "./resources/"; 
    public static final String PIZZA_NS = "http://www.co-ode.org/ontologies/pizza/pizza.owl#"; 

    public void run() 
    { 
     // Prefix/Header for SPARQL requests 
     final String prefix = "prefix pizza: <" + PIZZA_NS + ">\n" 
       + "prefix rdfs: <" + RDFS.getURI() + ">\n" + "prefix owl: <" 
       + OWL.getURI() + ">\n"; 
     // Prefix for classes, individuals, ... for every object 
     final String NS = PIZZA_NS; 

     System.out.println("CREATE THE BASE MODEL\n"); 
     // CREATE THE BASE MODEL 
     OntModel base = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM); 
     base.read(SOURCE + "pizza.owl.rdf", "RDF/XML"); 

     System.out.println("CREATE THE REASONING MODEL USING THE BASE\n"); 
     // CREATE THE REASONING MODEL USING THE BASE 
     OntModel inf = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_MICRO_RULE_INF, base); 
     // OWL_MEM_MICRO_RULE_INF // It works + Very quick 
     // OWL_MEM_MINI_RULE_INF // It works + Slow (40Mins) + 1,1Go RAM (Validity is slow) 
     // OWL_MEM_RULE_INF // It works (mights loop if error) + VERY SLOW + 2,1 GO RAM (unfinished) 
     // OWL_MEM_TRANS_INF // It works (SPARQL mights not work) + Ultra Speed/No inference 

     System.out.println("CREATE INDIVIDUALS FOR TESTING PURPOSE\n"); 
     // CREATE INDIVIDUALS FOR TESTING PURPOSE 

     // Instantiate each useful Class 
     OntClass ThingClass = base.getOntClass(NS + "owl:Thing"); 
     OntClass FoodClass = base.getOntClass(NS + "Food"); 
     OntClass IceCreamClass = base.getOntClass(NS + "IceCream"); 
     OntClass PizzaClass = base.getOntClass(NS + "Pizza"); 
     OntClass MozzaToppingClass = base.getOntClass(NS + "MozzarellaTopping"); 
     OntClass DeepPanBaseClass = base.getOntClass(NS + "DeepPanBase"); 

     // Instantiate each useful Property (relation) 
     OntProperty hasIngredientProperty = base.createObjectProperty(NS + "hasIngredient"); 
     OntProperty hasBaseProperty = base.createObjectProperty(NS + "hasBase"); 
     OntProperty hasToppingProperty = base.createObjectProperty(NS + "hasTopping"); 

     // Instantiate each useful individual 
     Individual MozzaTopping = base.createIndividual(NS + "MyMozzaTopping", MozzaToppingClass); 
     Individual DeepPanBase = base.createIndividual(NS + "MyDeepPanBase", DeepPanBaseClass); 

     /* 
     * BEGINNING OF THE TESTS HERE 
     */ 
     System.out.println("\nTEST VALIDITY BEFORE ADDING INDIVIDUALS\n"); 
     checkValidity(inf); 

     // Instantiate testing individuals 
     // MyPizza1 : individual with 2 classes simultaneously (Mozza & DeepPan) 
     Individual MyPizza1 = base.createIndividual(NS + "MyPizza1", ThingClass); 
     MyPizza1.setOntClass(MozzaToppingClass); 
     MyPizza1.addOntClass(DeepPanBaseClass); 

     System.out.println("\nTest MyPizza1\n"); 
     showAsserted(base, NS + "MyPizza1"); 
     showInferred(inf, NS + "MyPizza1"); 
     System.out.println("\nTest Validity of MyPizza1 : "); 
     checkValidity(inf); // ERROR 

     MyPizza1.remove(); 
     System.out.println("\nRemove MyPizza1, Validity should be OK now : "); 
     checkValidity(inf); // OK 

     // MyPizza2 : individual of class "Food", linked with Mozza & DeepPan 
     Individual MyPizza2 = base.createIndividual(NS + "MyPizza2", FoodClass); 
     MyPizza2.addProperty(hasBaseProperty, DeepPanBase); 
     MyPizza2.addProperty(hasToppingProperty, MozzaTopping); 

     System.out.println("\nTest MyPizza2\n"); 
     showAsserted(base, NS + "MyPizza2"); 
     showInferred(inf, NS + "MyPizza2"); 
     System.out.println("\nTest Validity of MyPizza2 : "); 
     checkValidity(inf); // OK 

     MyPizza2.remove(); 
     System.out.println("\nRemove MyPizza2, Validity should be OK now : "); 
     checkValidity(inf); // OK 

     // MyPizza3 : individual of class "DeepPanBase", linked with Mozza 
     Individual MyPizza3 = base.createIndividual(NS + "MyPizza3", DeepPanBaseClass); 
     MyPizza3.addProperty(hasToppingProperty, MozzaTopping); 

     System.out.println("\nTest MyPizza3\n"); 
     showAsserted(base, NS + "MyPizza3"); 
     showInferred(inf, NS + "MyPizza3"); 
     System.out.println("\nTest Validity of MyPizza3 : "); 
     checkValidity(inf); // ERROR 

     MyPizza3.remove(); 
     System.out.println("\nRemove MyPizza3, Validity should be OK now : "); 
     checkValidity(inf); // OK 

     // IceCream : individual of class "IceCream", linked with Moza & DeePan 
     Individual MyIceCream = base.createIndividual(NS + "MyIceCream", IceCreamClass); 
     MyIceCream.addProperty(hasBaseProperty, DeepPanBase); 
     MyIceCream.addProperty(hasToppingProperty, MozzaTopping); 

     System.out.println("\nTest IceCream\n"); 
     showAsserted(base, NS + "MyIceCream"); 
     showInferred(inf, NS + "MyIceCream"); 
     System.out.println("\nTest Validity of IceCream : "); 
     checkValidity(inf); 

     /* 
     * END OF THE TESTS HERE 
     */ 

     System.out.println("End Tests\n"); 
    } 

    protected void showAsserted(OntModel m, String individualURI) 
    { 
     // list the asserted types 
     Individual instance = m.getIndividual(individualURI); // BASE 
     for (Iterator<Resource> i = instance.listRDFTypes(false); i.hasNext();) 
     { 
      System.out 
        .println(instance.getURI() + " is asserted in class " + i.next()); 
     } 
    } 

    protected void showInferred(OntModel m, String individualURI) 
    { 
     // list the inferred types 
     Individual instance = m.getIndividual(individualURI); // INFERED 
     for (Iterator<Resource> i = instance.listRDFTypes(false); i.hasNext();) 
     { 
      System.out.println(
        instance.getURI() + " is inferred to be in class " + i.next()); 
     } 
    } 

    protected void checkValidity(OntModel inf) 
    { 
     ValidityReport validity = inf.validate(); 
     if (validity.isValid()) 
     { 
      System.out.println("OK"); 
     } 
     else 
     { 
      System.out.println("Conflicts"); 
      for (Iterator i = validity.getReports(); i.hasNext();) 
      { 
       System.out.println(" - " + i.next()); 
      } 
     } 
    } 

} 

Pour rendre le code fonctionne sur Eclipse ou autre , vous devez d'abord mettre le fichier pizza ontologie (pizza.owl.rdf) dans un dossier nommé "resources", et ajouter ces JAR (dans Eclipse: Build Path -> Configurer le Build Build -> Ajouter des JARs):

• commons-cli-1.3.jar
• commons-lang3-3.4.jar
• httpclient-4.5.2.jar
• httpclient-cache-4.5.2.jar
• httpcore-4.4.4.jar
• jackson-annotations-2.7. 0.jar
• jackson-core-2.7.4.jar
• Jackson-DataBind-2.7.4.jar
• Jena-ARQ-3.3.0.jar
• jena-base-3.3.0. pot
• jena-core-3.3.0.jar
• jena-iri-3.3.0.jar
• Jena-rdfconnection-3.3.0.jar
• Jena-goyave-ombragé 3.3.0.jar
• jsonld-java-0.9.0.jar
• libthrift-0.9.3.jar
• log4j-1.2.17.jar
• slf4j-api-1.7.21.jar
• slf4j-log4j12-1.7 .21.jar
• xercesImpl-2.11.0.jar
• xml-apis-1.4.01.jar

Answer 2

Afin d'améliorer la réponse, voici un petit code pour le chargement d'un modèle avec Jena, lancer un reasonner sur elle, ajouter des individus (qui créent des déductions) et faire de multiples demandes SPARQL sur le modèle de base et le modèle inférer pour obtenir les personnes suivantes y classe:

package Jena_Reasoner_SPARQL; 

import java.util.Date; 
import java.util.Iterator; 

import org.apache.jena.ontology.Individual; 
import org.apache.jena.ontology.OntClass; 
import org.apache.jena.ontology.OntModel; 
import org.apache.jena.ontology.OntModelSpec; 
import org.apache.jena.ontology.OntProperty; 
import org.apache.jena.query.Query; 
import org.apache.jena.query.QueryExecution; 
import org.apache.jena.query.QueryExecutionFactory; 
import org.apache.jena.query.QueryFactory; 
import org.apache.jena.query.ResultSet; 
import org.apache.jena.query.ResultSetFormatter; 
import org.apache.jena.rdf.model.Model; 
import org.apache.jena.rdf.model.ModelFactory; 
import org.apache.jena.rdf.model.Resource; 
import org.apache.jena.reasoner.ValidityReport; 
import org.apache.jena.vocabulary.OWL; 
import org.apache.jena.vocabulary.RDFS; 

public class Simple_Reasoner_and_SPARQL_Request 
{ 
    public static final String SOURCE  = "./resources/"; 
    public static final String PIZZA_NS = "http://www.co-ode.org/ontologies/pizza/pizza.owl#"; 
    public static final String prefix  = "prefix pizza: <" + PIZZA_NS + ">\n" 
              + "prefix rdfs: <" + RDFS.getURI() + ">\n" 
              + "prefix owl: <" + OWL.getURI() + ">\n"; 

    public static void main(String[] args) 
    { 
     System.out.println("BEGIN " + new Date()); 

     new Simple_Reasoner_and_SPARQL_Request().run(); 

     System.out.println("END " + new Date()); 
    } 

    public void run() 
    { 
     String NS = PIZZA_NS; 

     System.out.println("CREATE AND LOAD THE BASE MODEL"); 
     // CREATE AND LOAD THE BASE MODEL 
     OntModel base = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM); 
     base.read(SOURCE + "pizza.owl.rdf", "RDF/XML"); 

     System.out.println("CREATE THE REASONING MODEL USING THE BASE\n"); 
     // CREATE THE REASONING MODEL USING THE BASE 
     OntModel inf = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_MICRO_RULE_INF, base); 
     // OWL_MEM_MICRO_RULE_INF // It works + Very quick 
     // OWL_MEM_MINI_RULE_INF // It works + Slow (40Mins) + 1,1Go RAM (Validity is slow) 
     // OWL_MEM_RULE_INF // It works (mights loop if error) + VERY SLOW + 2,1Go RAM (unfinished) 
     // OWL_MEM_TRANS_INF // It works (SPARQL mights not work) + Ultra Speed/No inference 

     System.out.println("CREATE INDIVIDUALS FOR TESTING PURPOSE\n"); 
     // CREATE INDIVIDUALS FOR TESTING PURPOSE 

     // Instantiate each useful Class 
     OntClass ThingClass = base.getOntClass(NS + "owl:Thing"); 
     OntClass FoodClass = base.getOntClass(NS + "Food"); 
     OntClass IceCreamClass = base.getOntClass(NS + "IceCream"); 
     OntClass PizzaClass = base.getOntClass(NS + "Pizza"); 
     OntClass MozzaToppingClass = base.getOntClass(NS + "MozzarellaTopping"); 
     OntClass DeepPanBaseClass = base.getOntClass(NS + "DeepPanBase"); 

     // Instantiate each useful Property (relation) 
     OntProperty hasIngredientProperty = base.createObjectProperty(NS + "hasIngredient"); 
     OntProperty hasBaseProperty = base.createObjectProperty(NS + "hasBase"); 
     OntProperty hasToppingProperty = base.createObjectProperty(NS + "hasTopping"); 

     // Instantiate each useful individual 
     Individual MozzaTopping = base.createIndividual(NS + "MyMozzaTopping", MozzaToppingClass); 
     Individual DeepPanBase = base.createIndividual(NS + "MyDeepPanBase", DeepPanBaseClass); 

     /* 
     * BEGINNING OF THE TESTS HERE 
     */ 
     System.out.println("\nTEST VALIDITY BEFORE ADDING INDIVIDUALS " + new Date() + "\n"); 
     checkValidity(inf); 

     // Instantiate testing individuals 
     // MyPizza1 : individual of class "Food", linked with Mozza & DeepPan 
     Individual MyPizza1 = base.createIndividual(NS + "MyPizza1", FoodClass); 
     MyPizza1.addProperty(hasBaseProperty, DeepPanBase); 
     MyPizza1.addProperty(hasToppingProperty, MozzaTopping); 

     System.out.println("\nTest MyPizza1 " + new Date() + "\n"); 
     showAsserted(base, NS + "MyPizza1"); 
     showInferred(inf, NS + "MyPizza1"); 
     System.out.println("\nTest Validity of MyPizza1 : " + new Date()); 
     checkValidity(inf); // OK 

     // SPARQL Tests now 
     System.out.println("\nSPARQL TESTS\n"); 
     printPrefix(); 

     // Research every Food 
     System.out.println("\nResearch Food in Base model"); 
     showQuery(base, 
       prefix + "SELECT ?individual " + "WHERE { " 
         + " ?individual a pizza:Food . " 
         + " FILTER (! isBlank(?individual)) " + "} "); 

     System.out.println("\nResearch Food in Inference model"); 
     showQuery(inf, 
       prefix + "SELECT ?individual " + "WHERE { " 
         + " ?individual a pizza:Food . " 
         + " FILTER (! isBlank(?individual)) " + "} "); 

     // Research every CheeseyPizza 
     System.out.println("\nResearch CheeseyPizza in Base model"); 
     showQuery(base, 
       prefix + "SELECT ?individual " + "WHERE { " 
         + " ?individual a pizza:CheeseyPizza . " 
         + " FILTER (! isBlank(?individual)) " + "} "); 

     System.out.println("\nResearch CheeseyPizza in Inference model"); 
     showQuery(inf, 
       prefix + "SELECT ?individual " + "WHERE { " 
         + " ?individual a pizza:CheeseyPizza . " 
         + " FILTER (! isBlank(?individual)) " + "} "); 

     /* 
     * END OF THE TESTS HERE 
     */ 

     System.out.println("End Tests\n"); 
    } 

    protected void showAsserted(OntModel m, String individualURI) 
    { 
     // list the asserted types 
     Individual instance = m.getIndividual(individualURI); // BASE 
     for (Iterator<Resource> i = instance.listRDFTypes(false); i.hasNext();) 
     { 
      System.out 
        .println(instance.getURI() + " is asserted in class " + i.next()); 
     } 
    } 

    protected void showInferred(OntModel m, String individualURI) 
    { 
     // list the inferred types 
     Individual instance = m.getIndividual(individualURI); // INFERED 
     for (Iterator<Resource> i = instance.listRDFTypes(false); i.hasNext();) 
     { 
      System.out.println(
        instance.getURI() + " is inferred to be in class " + i.next()); 
     } 
    } 

    protected void checkValidity(OntModel inf) 
    { 
     ValidityReport validity = inf.validate(); 
     if (validity.isValid()) 
     { 
      System.out.println("OK"); 
     } 
     else 
     { 
      System.out.println("Conflicts"); 
      for (Iterator i = validity.getReports(); i.hasNext();) 
      { 
       System.out.println(" - " + i.next()); 
      } 
     } 
    } 

    protected void printPrefix() 
    { 
     System.out.println(prefix); 
    } 

    protected void showQuery(Model m, String q) 
    { 
     Query query = QueryFactory.create(q); 
     QueryExecution qexec = QueryExecutionFactory.create(query, m); 
     try 
     { 
      ResultSet results = qexec.execSelect(); 
      ResultSetFormatter.out(results, m); 
     } 
     finally 
     { 
      qexec.close(); 
     } 

    } 
}