Hello Lorenz, Dave, I have used the above method and suddenly I get this
exception:

 WARN [AWT-EventQueue-0] (Rule.java:947) - Rule references unimplemented
functor: ^

Where it comes from?

On Sun, Nov 27, 2016 at 2:59 PM, Lorenz B. <
buehm...@informatik.uni-leipzig.de> wrote:

>
>
> > Hi Dave,
> >
> > So in that case we dont need to add non-inference model to the generic
> > reasoner because after all, our whole data is in the model.
> Yes, it is simply nested:
> Raw model A is "contained" in the inferred RDFS model B.
> B is "contained" in your user-defined rule model C.
> Thus, A is "contained" in C.
> >
> >
> > On Sat, Nov 26, 2016 at 11:55 AM, Dave Reynolds <
> dave.e.reyno...@gmail.com>
> > wrote:
> >
> >> On 25/11/16 13:54, tina sani wrote:
> >>
> >>> I have something like this after my Jena forward chain rules and SPARQL
> >>> query:
> >>>
> >>>  Reasoner reasoner1 = new GenericRuleReasoner(Rule.parseRules(rule));
> >>>         InfModel inf = ModelFactory.createInfModel(reasoner1, model);
> >>>
> >>> Reasoner reasoner2 = ReasonerRegistry.getRDFSReasoner();
> >>>
> >>> InfModel inf2 = ModelFactory.createRDFSModel(model);
> >>>
> >> If you want your rules to see the results of the RDFS closure then you
> >> need something more like:
> >>
> >>     InfModel inf = ModelFactory.createRDFSModel(model);
> >>     Reasoner reasoner1 = new GenericRuleReasoner(Rule.
> parseRules(rule));
> >>     InfModel inf2 = ModelFactory.createInfModel(reasoner1, inf);
> >>
> >> Dave
> >>
> >>
> >> On Fri, Nov 25, 2016 at 4:46 PM, tina sani <tinamadri...@gmail.com>
> wrote:
> >>> So all I should so is to create rdfs model:
> >>>> InfModel inf2 = ModelFactory.createRDFSModel();
> >>>>
> >>>> What would be the arguments of the ModelFactory.createRDFSModel(). I
> >>>> have two models here, one the simple non inference model and other the
> >>>> inference model : InfModel inf = ModelFactory.createInfModel(
> reasoner,
> >>>> model);
> >>>>
> >>>>
> >>>>
> >>>>
> >>>> On Fri, Nov 25, 2016 at 3:59 PM, Lorenz B. <buehm...@informatik.uni-
> >>>> leipzig.de> wrote:
> >>>>
> >>>>
> >>>>> Yes I use GenericRuleReasoner, so using the following rules along
> with
> >>>>> my
> >>>>>
> >>>>>> own rules will solve the problem?
> >>>>>>
> >>>>>> ?x rdfs:subClassOf emp:ContractEmployee--> ?x rdfs:subClassOf
> >>>>>>
> >>>>> emp:Employee
> >>>>>
> >>>>>> ?x rdfs:subClassOf emp:PermanantEmployee--> ?x rdfs:subClassOf
> >>>>>>
> >>>>> emp:Employee
> >>>>> That might be incomplete as rdfs:subClassOf is transitive. Simply use
> >>>>> the RDFS reasoning.
> >>>>>
> >>>>>> On Thu, Nov 24, 2016 at 11:39 AM, Lorenz B. <
> >>>>>> buehm...@informatik.uni-leipzig.de> wrote:
> >>>>>>
> >>>>>>  If I pass OntModelSpec.OWL_MEM_MICRO_RULE_INF” to the OntModel,
> will
> >>>>>>> it do
> >>>>>>>
> >>>>>>>> the RDFS reasoning?
> >>>>>>>>
> >>>>>>> See [1] in general and in particular [2] which shows how to setup
> an
> >>>>>>> RDFS reasoner
> >>>>>>>
> >>>>>>> InfModel inf = ModelFactory.createRDFSModel(rdfsExample);
> >>>>>>>
> >>>>>>> or
> >>>>>>>
> >>>>>>> Reasoner reasoner = ReasonerRegistry.getRDFSReasoner();
> >>>>>>> InfModel inf = ModelFactory.createInfModel(reasoner, rdfsExample);
> >>>>>>>
> >>>>>>> [1] https://jena.apache.org/documentation/inference/ [2]
> >>>>>>> https://jena.apache.org/documentation/inference/#generalExamples
> >>>>>>>
> >>>>>>>> b) adding the particular rules to your set of rules
> >>>>>>>>  I have already created the rules, mentioned in my first email.
> You
> >>>>>>>>
> >>>>>>> means
> >>>>>> rules other than that?
> >>>>>>> I don't know how you setup your rules, but if you use the
> >>>>>>> GenericRuleReasoner it does only apply your rules and you would
> have
> >>>>>>> to
> >>>>>>> add the rules that do the rdfs:subClass/rdf:type inference.
> >>>>>>>
> >>>>>>>> On Wed, Nov 23, 2016 at 11:50 AM, Lorenz B. <
> >>>>>>>> buehm...@informatik.uni-leipzig.de> wrote:
> >>>>>>>>
> >>>>>>>> Dave meant that you need an additional layer of reasoning like
> RDFS
> >>>>>>>> or
> >>>>>> even less to get the inferences that you describe.
> >>>>>>>>> This can be done by
> >>>>>>>>>
> >>>>>>>>> a) nesting two InfModels one that works on your specific rules
> and
> >>>>>>>>>
> >>>>>>>> one
> >>>>>> that uses some kind of RDFS or
> >>>>>>>>> b) adding the particular rules to your set of rules
> >>>>>>>>>
> >>>>>>>>> Ok sorry Dave, actually I did not completely understand your
> answer.
> >>>>>>>>>> "You could have an inference model with the appropriate
> >>>>>>>>>>
> >>>>>>>>> configuration
> >>>>>> to
> >>>>>>>> deduce membership of employee"
> >>>>>>>>>> Yes I have the inference model:
> >>>>>>>>>>  Reasoner reasoner = new GenericRuleReasoner(Rule.parse
> >>>>>>>>>>
> >>>>>>>>> Rules(rule));
> >>>>>>         InfModel infer = ModelFactory.createInfModel(reasoner,
> >>>>>>>>> model);
> >>>>>>>>>>             Query query = QueryFactory.create(queryString);
> >>>>>>>>>>
> >>>>>>>>>>      QueryExecution qe = QueryExecutionFactory.create(query,
> >>>>>>>>>>
> >>>>>>>>> infer);
> >>>>>>>>>> What additionally I have to do apart from my Jena rule (Forward
> >>>>>>>>>>
> >>>>>>>>> Chain)
> >>>>>> mentioned in previous email and the inference model.
> >>>>>>>>>> And of course, I will have a SPARQL query :
> >>>>>>>>>> Select *
> >>>>>>>>>> where{ ?x rdf:type emp:QualifiedEmployee }
> >>>>>>>>>>
> >>>>>>>>>> On Tue, Nov 22, 2016 at 6:03 PM, Dave Reynolds <
> >>>>>>>>>>
> >>>>>>>>> dave.e.reyno...@gmail.com>
> >>>>>>>>>
> >>>>>>>>>> wrote:
> >>>>>>>>>>
> >>>>>>>>>> On 22/11/16 14:56, tina sani wrote:
> >>>>>>>>>>> Let me explain a bit.
> >>>>>>>>>>>> String rule = "[rule1:(?x http://www.w3.org/1999/02/22-
> >>>>>>>>>>>>
> >>>>>>>>>>> rdf-syntax-ns#type
> >>>>>>>>>> http://www.semanticweb.org#Employee) "
> >>>>>>>>>>>>                 + "( ?x http://www.semanticweb.org#Salary
> >>>>>>>>>>>>
> >>>>>>>>>>> ?salary
> >>>>>> )"
> >>>>>>>>                 + "greaterThan(?salary, 10,00) "
> >>>>>>>>>>>>                 + " ->  (?x http://www.w3.org/1999/02/22-r
> >>>>>>>>>>>> df-syntax-ns#type
> >>>>>>>>>>>> http://www.semanticweb.org#QualifiedEmployee. )]"
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Classes in my ontology are
> >>>>>>>>>>>>
> >>>>>>>>>>>> Employee (Super class of all employees)
> >>>>>>>>>>>>    * ContractEmployee*  (Subclass of Employee)
> >>>>>>>>>>>>            FinanceManager
> >>>>>>>>>>>>             ITManager          (Subclasses of
> ContractEmployee)
> >>>>>>>>>>>>    * PermanantEmployee   *(Subclass of Employee)
> >>>>>>>>>>>>             Analyst
> >>>>>>>>>>>>             Programmer
> >>>>>>>>>>>>
> >>>>>>>>>>>> In this case, will I use ?x rdf:type Employee  or  ?x rdf:type
> >>>>>>>>>>>>  ContractEmployee
> >>>>>>>>>>>> All the instances are either from subclasses  *
> FinanceManager ,
> >>>>>>>>>>>>
> >>>>>>>>>>> ITManager
> >>>>>>>>>> or Analyst, Programmer*
> >>>>>>>>>>>> *Is it must that if I use ?x rdf:type Employee, then
> >>>>>>>>>>>>
> >>>>>>>>>>> FinanceManager &
> >>>>>> ITManager should also be sub classes of general super class
> >>>>>>>>>>> "Employee"
> >>>>>>>> ?*
> >>>>>>>>>> I don't think any of these details change my earlier answer,
> quoted
> >>>>>>>>>> below.
> >>>>>>>>>> Dave
> >>>>>>>>>>>
> >>>>>>>>>>> On Tue, Nov 22, 2016 at 5:30 PM, Dave Reynolds <
> >>>>>>>>>>>
> >>>>>>>>>> dave.e.reyno...@gmail.com>
> >>>>>>>>>> wrote:
> >>>>>>>>>>>> On 22/11/16 10:12, tina sani wrote:
> >>>>>>>>>>>>
> >>>>>>>>>>>>> Inline image 1
> >>>>>>>>>>>>> The mail list doesn't support attachments so the image didn't
> >>>>>>>>>>>>>
> >>>>>>>>>>>> come
> >>>>>> through.
> >>>>>>>>>>>>> However, I'm guessing it included a class Employee with
> >>>>>>>>>>>>>
> >>>>>>>>>>>> sub-classes
> >>>>>> ContractEmployee and PermanantEmployee.
> >>>>>>>>>>>>> I have this ontology: Now if I want to use some rules like
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> if x rdf:type Employee and ?x salary>Euro10,000. then ?x
> >>>>>>>>>>>>>> QualifiedEmployee.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> My question here is should I use ?x rdf:type Employee or ?x
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> rdf:type
> >>>>>>>> ContractEmployee or PermanantEmployee
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Depends on your set up.
> >>>>>>>>>>>>> You could have an inference model with the appropriate
> >>>>>>>>>>>>>
> >>>>>>>>>>>> configuration
> >>>>>> to
> >>>>>>>>>> deduce membership of employee and then query that with SPARQL or
> >>>>>>>>>>>> with
> >>>>>>>> a
> >>>>>>>>>> second inference model with your own rules in.
> >>>>>>>>>>>>> If you want just one layer of rules and want to combine
> OWL/RDFS
> >>>>>>>>>>>>>
> >>>>>>>>>>>> with
> >>>>>>>> your
> >>>>>>>>>>>>> custom rules then that's possible (so long as you set all the
> >>>>>>>>>>>>>
> >>>>>>>>>>>> appropriate
> >>>>>>>>>> flags, see documentation) but make sure that your own rules are
> >>>>>>>>>>>> backward
> >>>>>>>>>> not forward rules. [The default Jena rule sets for RDFS and OWL
> >>>>>>>>>>>> are
> >>>>>> hybrid
> >>>>>>>>>>>>> rules so some of the inferences are only available to
> backward
> >>>>>>>>>>>>>
> >>>>>>>>>>>> rules
> >>>>>> in
> >>>>>>>>>> the
> >>>>>>>>>>>>> same rule set.]
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Or if you don't want the cost of full inference then you can
> >>>>>>>>>>>>>
> >>>>>>>>>>>> indeed
> >>>>>> rewrite the "natural" query to explicitly check for the base
> >>>>>>>>>>>> memberships.
> >>>>>>>>>> Dave
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> --
> >>>>>>>>> Lorenz Bühmann
> >>>>>>>>> AKSW group, University of Leipzig
> >>>>>>>>> Group: http://aksw.org - semantic web research center
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> --
> >>>>>>> Lorenz Bühmann
> >>>>>>> AKSW group, University of Leipzig
> >>>>>>> Group: http://aksw.org - semantic web research center
> >>>>>>>
> >>>>>>> --
> >>>>> Lorenz Bühmann
> >>>>> AKSW group, University of Leipzig
> >>>>> Group: http://aksw.org - semantic web research center
> >>>>>
> >>>>>
> >>>>>
> --
> Lorenz Bühmann
> AKSW group, University of Leipzig
> Group: http://aksw.org - semantic web research center
>
>

Reply via email to