# Unsafe Rules and existential variables

• From: <editor@content-wire.com>
• Date: Wed, 20 Dec 2006 05:36:35 -0500
• Message-ID: <380-2200612320103635795@M2W027.mail2web.com>
```Matt
I am sorry that an answer to your q has not turned up yet

Your problem has been bugging me though - although I do not have a reply
myself
I do however wonder - why use unsafe rules? It's like getting stuck in the
mud, then asking how do I get out, and invoking an unnecessarily

An usafe rule from what I know is used when there is uncertainty in the
knowledge
by an 'unsorted' logical and inferencing question.

I think developing a higher level of logic and reasoning is a safe way of
avoding unsafe rules, thus a different approach to avoiding the problem in
the first place, I guess

PDM

----- Original Message -----
From: "Matt Williams" <>
To: "Semantic Web" <semantic-web@w3.org>
Sent: Tuesday, December 05, 2006 11:16 PM
Subject: Unsafe Rules and existential variables

>
> Dear All,
>
> This is a slightly odd OWL question, but I thought this would be a good
> forum for it.
>
> I have read some of the work on rules & Dls, but one of the remaining
> `itches' I have is with unsafe rules (that is rules, where there are
> variables in the head that do not appear in the body).
>
> I am trying to work with a system that uses a very simple rules syntax
> (propositional logic, but with variables so that the rules act as
> schemas for all groundings of the variables that satisfy the rules) and
> would like to be able to use unsafe rules. The problem is that in many
> cases I can't ground the unsafe heads because the point of the rule is
> to infer the existence of new individuals.Eg.:
>
> Given A(MsJones) being in the A Box, and a rule of the form:
>
> r1: A(x) -> B(x,y) & C(y) (Unsafe head)
>
> Ground(r1): A(MsJones) -> B(MsJones,y) & C(y)
>
> (as there is no grounding for y in the a-box)
>
>
> One solution that has been suggested (by Boris Motik, I think) is that
> one rolls-up (using Horrocks A-Box query technique) the (unsafe) head of
> the rule to form a new class definition. So now I have:
>
> r1: A(x) -> SpecialBC_Class(x) (Newly-safe head)
>
> Ground(r1): A(MsJones) -> SpecialBC_Class(MsJones)
>
> The problem with this is that I can't then `get' at the variables in the
> head very easily, which I want to do for other reasons.
>
> The other reason it seems a little unsatisfactory is that if rolling-up
> produces an existentially quantified formula, and this is then
> Skolemised, you get something with anonymous individuals in, which
> should be possible to do without going through the DL route. So if I
> follow the procedure above, I get:
>
>
> r1: A(x) -> SpecialBC_Class(x)
>
> Ground(r1): A(MsJones) -> SpecialBC_Class(MsJones)
>
> where there is a TBox axiom SpecialBC_Class = A & \exists B.C, so the
> ABox now contains:
>
> A(MsJones)
> SpecialBC_Class(MsJones) and hence
> B(MsJones,_Anon1234), C(_Anon1234)
>
> My question is whether this would be better off done in the (simple)
> rule language, rather than ducking between the rules and DL, which seems
> both inelegant (much to-ing & fro0ing) and a little dishonest (since we
> know it is happening, shouldn't we do it locally?).
>
> Thanks a lot, and apologies for the long post.
>
> Matt

--------------------------------------------------------------------
mail2web - Check your email from the web at
http://mail2web.com/ .
```

Received on Wednesday, 20 December 2006 10:36:53 UTC