This message was cross-posted to stack-exchange. If someone wants to answer there, the URL is http://stackoverflow.com/questions/15922343/drools-queries-strange-depend... . I'm somewhat new to Drools, and experienced this strange behavior during writing a query. To start with, the Hotel class here is a subclass of PlaceImpl, which implements the interface Place. PlaceImpl itself is a subclass (via another class) of OntologyClassImpl, where the method getClasses() is implemented in the most trivial way: it returns an already existing java.util.Set of objects. In short, getClasses() is accessible from both Place interface and Hotel class. My problem is this: The following query does not return any result even when there are matching Hotels. query "qryRomantic" $e: Hotel (classes contains Semantics.AMB_Romantic) end However, if I replace Hotel with Place, then the /query returns desired results/, although the ONLY condition-setting rules are written for Hotel, as follows. (This rule actually gets fired several times.) rule "Set semantic class Romantic" no-loop when $hotel: Hotel( ... conditions go here ... ) then modify ($hotel){ addToClasses(Semantics.AMB_Romantic) } end It does not end there. if I add another query to the rule file, for exactly the opposite condition as follows, query "qryNonRomantic" $e: Hotel (classes not contains Semantics.AMB_Romantic) end then the /first query/ starts to return the desired results, /EVEN WHEN the new query is not called at all/! What am I doing wrong? I'd be really grateful for any pointers. ------------------------------------------------------------------------ View this message in context: drools queries: strange dependency <http://drools.46999.n3.nabble.com/drools-queries-strange-dependency-tp402... Sent from the Drools: User forum mailing list archive <http://drools.46999.n3.nabble.com/Drools-User-forum-f47000.html> at Nabble.com. _______________________________________________ rules-users mailing list rules-users(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/rules-users

Hi Davide, Thanks a lot for the information and your time spent on troubleshooting the scenario with a test case. I'm using 5.5.0; as I mentioned, I'm a newbie. I'll try to get 5.5.1 compiled and running (on windows), I'm reading whatever the documentation I can find on how to do this. Github source seems to be on 6.0.0, I'll try with that one if all else fails. I'm loading the rule base using a KnowledgeBuilder, and yes I do check for errors explicitly after building. The rule file with the problem I mentioned does not produce any errors, other than the result that doesn't make sense. Thanks again, Upali -- View this message in context: http://drools.46999.n3.nabble.com/drools-queries-strange-dependency-tp402... Sent from the Drools: User forum mailing list archive at Nabble.com. _______________________________________________ rules-users mailing list rules-users(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/rules-users

Thanks a lot again, you made my life easy with the build instructions :) Yes I'm trying to do an integration. I have some experience with ontologies and want to experiment with drools as an alternative. OWL with reasoners like Fact ++ are pretty much good for the job, except for the fact that they handle individual data bits in quite a cumbersome way. It was because of this reason that I wanted to experiment on other ways of modeling a knowledge structure with better facilities for querying large amounts of factual data. I'm giving drools a try, but I'm not entirely sure if drools can do things as powerful as a reasoner. Basically, I'd like to be able to let the data lie (without firing any "events" until necessary) and query the inferences in a first-order logic like manner. This is very space-efficient in data-heavy scenarios. I know that this isn't the traditional way drools is designed to work. I'm trying to solve the inference problem by dynamically adding semantic classes to each object to store all the possible inferences about it, so they can be queried later. Problem with this approach is that it gets out of hand very quickly, because the enumerated number of such inferences can be HUGE even for a moderate KB. Backward chaining will eventually solve this problem, but it seems that the constructs available for that in drools queries are not too matured at the moment. For instance they don't seem to support numerical inequality operators (or I am wrong, which is also very likely). Thank you again for the quick help, Upali On 11/04/2013 14:14, Davide Sottara wrote: > You should be able to > git clone ... > the droolsjbpm repository, then > git checkout -t origin/5.5.x > > this should switch to 5.5.1-SNAPSHOT (you can check the pom in the root > folder) > eventually, mvn clean install should do the trick. > > See also the readme.md in github > > Btw, it seems that you're working with rule/ontology integrations.. > would you > be interested in sharing thoughts? > > Davide > > On 04/11/2013 01:29 AM, upalik wrote: >> Hi Davide, >> >> Thanks a lot for the information and your time spent on troubleshooting the >> scenario with a test case. >> >> I'm using 5.5.0; as I mentioned, I'm a newbie. I'll try to get 5.5.1 >> compiled and running (on windows), I'm reading whatever the documentation I >> can find on how to do this. Github source seems to be on 6.0.0, I'll try >> with that one if all else fails. >> >> I'm loading the rule base using a KnowledgeBuilder, and yes I do check for >> errors explicitly after building. The rule file with the problem I mentioned >> does not produce any errors, other than the result that doesn't make sense. >> >> Thanks again, >> Upali >> >> >> >> -- >> View this message in context: http://drools.46999.n3.nabble.com/drools-queries-strange-dependency-tp402... >> Sent from the Drools: User forum mailing list archive at Nabble.com. >> _______________________________________________ >> rules-users mailing list >> rules-users(a)lists.jboss.org >> https://lists.jboss.org/mailman/listinfo/rules-users >> > _______________________________________________ > rules-users mailing list > rules-users(a)lists.jboss.org > https://lists.jboss.org/mailman/listinfo/rules-users -- *Upali Kohomban*, PhD Research Fellow CodeGen International 29 Breybrooke Street, Colombo 02, Sri Lanka *T:* +94 112 470 740 *F:* +94 112 470 749 *W:* http://codegen.net _______________________________________________ rules-users mailing list rules-users(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/rules-users

Hi, Sorry for the late reply, I was away from mail. I'm fine with assumptions such as unique name and closed world because whatever method I use these handicaps will be there in some form. In my case, why I can't go on with OWL/Logic is the issue of large amounts of factual data which change frequently, unlike, say, in Biomedical ontologies. For an instance, I want to model the semantics of a country's appeal as a holiday destination for a particular crowd depending on any events that makes it interesting for that crowd. These things can change on day-to-day basis depending on weather, currency rates, school holidays, ticket prices etc. OWL ontologies (as you must know) handle these kind of volatile data quite poorly. Unfortunately, its difficult to plug things to the reasoner at the facts-end of the OWL. This last bit is different for Drools. On the other hand, as I said, the number of possible inferences are near infinite, and unnecessary unless they are explicitly queried. For instance take a transitive relationship such as situated_in(x, y). If there are few levels of locality (say, country/district/city/town/suburb) there will be so many unnecessary inferences for the relationship in drools rules. With a backward chaining reasoner, these inferences won't fire unless queried. According to my limited understanding of drools, this is the main issue one could come up against using drools here. I was trying to work around that fact by using the (apparently recent) backward-chaining queries, and by delegating some of the worse (transitive etc) clauses to POJO. I really enjoy being able to do that, even if I'm doing it wrong and there's a better way ;-) So far, I'm using a mix of technologies to get what I think is the best of both worlds: backward-chaining, POJO for logic itself at lower level for recursive rules, semantic classes to "store" inferences about stuff so they can be queried later. If there is a better way of doing this, I'd really love to know it. I'm aware that this is not ideal problem for an expert system or an ontology. However I need to model a little bit of semantics than a database-only system, and do it in an easily changeable way. Thanks, Upali On 12/04/2013 00:56, Davide Sottara wrote: > Ontology Reasoners and Rule Engines are quite different, can be > integrated under some assumptions, > but are definitely not easily interchangeable.. (unique name > assumption, closed world assumption, etc..) > Which one is better pretty much depends on the use case, which also > dictates the required level of > expressiveness of the language - even Fact++, Hermit and Pellet do > not support full FOL... > > This said, your case seems very interesting.. would you mind sharing > a few more details or a concrete example? > We would then be able to assess whether Drools is appropriate or not, > and which constructs could be > used (e.g. traits, hybrid chaining queries, tms, ...) to tackle the > complexity. > > Or maybe we could take it as a use case to improve the engine > capbilities :) > > Best > Davide > > > > > On 04/11/2013 05:01 AM, Upali Kohomban wrote: >> Thanks a lot again, you made my life easy with the build instructions :) >> >> Yes I'm trying to do an integration. I have some experience with >> ontologies and want to experiment with drools as an alternative. >> >> OWL with reasoners like Fact ++ are pretty much good for the job, >> except for the fact that they handle individual data bits in quite a >> cumbersome way. It was because of this reason that I wanted to >> experiment on other ways of modeling a knowledge structure with >> better facilities for querying large amounts of factual data. I'm >> giving drools a try, but I'm not entirely sure if drools can do >> things as powerful as a reasoner. >> >> Basically, I'd like to be able to let the data lie (without firing >> any "events" until necessary) and query the inferences in a >> first-order logic like manner. This is very space-efficient in >> data-heavy scenarios. I know that this isn't the traditional way >> drools is designed to work. I'm trying to solve the inference >> problem by dynamically adding semantic classes to each object to >> store all the possible inferences about it, so they can be queried >> later. Problem with this approach is that it gets out of hand very >> quickly, because the enumerated number of such inferences can be >> HUGE even for a moderate KB. Backward chaining will eventually solve >> this problem, but it seems that the constructs available for that in >> drools queries are not too matured at the moment. For instance they >> don't seem to support numerical inequality operators (or I am wrong, >> which is also very likely). >> >> Thank you again for the quick help, >> Upali >> >> >> >> >> >> >> On 11/04/2013 14:14, Davide Sottara wrote: >>> You should be able to >>> git clone ... >>> the droolsjbpm repository, then >>> git checkout -t origin/5.5.x >>> >>> this should switch to 5.5.1-SNAPSHOT (you can check the pom in the root >>> folder) >>> eventually, mvn clean install should do the trick. >>> >>> See also the readme.md in github >>> >>> Btw, it seems that you're working with rule/ontology integrations.. >>> would you >>> be interested in sharing thoughts? >>> >>> Davide >>> >>> On _______________________________________________ rules-users mailing list rules-users(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/rules-users

hi Davide, Your summary is quite accurate about my case. Thanks for the pointer, I will look in to hybrid chaining once I do a little investigation on why exactly the original problem occurred. I'm still having little issues with the 5.5.1 source compilation (for which your help worked flawlessly to get the source working, but there were test fails during the compilation. I will try myself to fix them before asking questions on that). As i said, the bigger problem is with the rules that are transitive in nature. Let's say there is a is_in rule which is used to derive spacial relationships. For instance, a concrete example is_in (uni_of_michigan, ann_arbor). is_in(ann_arbor, MI). is_in(MI, USA). is_in(A, C) <- is_in(A, B), is_in(B, C). I want to deduce (in general course of reasoning) such stuff as is_in(uni_of_michigan, USA), but if I do it in the regular drools way, I'd end up with a load of unnecessary deductions. This is the biggest problem I have. If you want a more involved concrete example, say I define (for the sake of simplicity) romantic(A) <- scenic(A), secluded(A). scenic(A) <- next_to(A, B), scenic_artefact(B). scenic_artefact(B) <- lake(B) or waterfall(B) or ... and so on secluded(A) <- [ situated further than N km from the nearest city ] Now this last rule is where logic gives way to POJO and databases. It seems to me that this is the most sensible thing to do. Also, this is as far as I want to go at the moment. (Having known the non-boolean reasoning ability of drools from your mail, I can think of many ways I want to use it :) ) I looked into your profile and saw that you have a background on the ontologies. Especially what you have mentioned under Drools - "Open Source Knowledge Integration and Reasoning Platform" in your university profile seems quite intersting and seems to be exactly the things I might be needing in the near future. I was thinking that I'll have to implement non-boolean reasoning using some fuzzy toolkit, if it becomes available with drools I'll be really happy to give it a try. If you have any material to share for further reading on your drools research, I'd be grateful. Thanks, Upali On 15/04/2013 03:10, Davide Sottara wrote: > Correct me if I'm wrong, I would summarize your requirements as follows: > - you need some "A-box" reasoning, but you are fine with a rule-based > approach > - the object-oriented integration Drools provides is quite convenient > - you have large data sets for which an opportunistic, > "query-oriented" approach > would work better rather than a fully generative "forward chaining" > approach > > Drools "hybrid-chaining" approach could be very useful here - I'm not > sure how > well documented it is, and how you are planning to use it, but it > would be interesting > to see one of your rules - even "stripped" of the details you don't > want to show - > to discuss the behaviour of the engine and its implications. > > I had a use case apparently very similar to yours some time ago.. I'm > working even > now on some experimental forms of rule/object/ontology integration. > The "trait" > feature might be an alternative to the explicit addition of classes > to objects .. it was > enhanced a few days ago to support updates and modifications. > If you have an ontology to begin with, you might also be interested > in the ontology -> class > conversion tool I'm working on even now > > Davide _______________________________________________ rules-users mailing list rules-users(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/rules-users

Correct me if I'm wrong, I would summarize your requirements as follows: - you need some "A-box" reasoning, but you are fine with a rule-based approach - the object-oriented integration Drools provides is quite convenient - you have large data sets for which an opportunistic, "query-oriented" approach would work better rather than a fully generative "forward chaining" approach Drools "hybrid-chaining" approach could be very useful here - I'm not sure how well documented it is, and how you are planning to use it, but it would be interesting to see one of your rules - even "stripped" of the details you don't want to show - to discuss the behaviour of the engine and its implications. I had a use case apparently very similar to yours some time ago.. I'm working even now on some experimental forms of rule/object/ontology integration. The "trait" feature might be an alternative to the explicit addition of classes to objects .. it was enhanced a few days ago to support updates and modifications. If you have an ontology to begin with, you might also be interested in the ontology -> class conversion tool I'm working on even now Davide