on the way to utilizes_reagent inference

[Alan Ruttenberg]

[Resend of a previous private thread]

In this first example we've inferred a !b property from a
superproperty !a, and what type the !b value is, even though we don't
know the value yet. This may be enough for what we need.

(with-ontology has-same-type ()
((object-property !a)
(object-property !b (super !a))
(class !c :partial)
(equivalent-classes
(intersection-of !c (restriction !a (some-values-from !c)))
(intersection-of !c (restriction !b (some-values-from !c))))
(individual !c1 (type !c) (value !a !c1)))
(describe !c1)
(print-db (instances (restriction !b (some-values-from !
c)))))

Individual http://example.com/#c1
All Types: ex:c
Direct Types: ex:c
!ex:a: !ex:c1
(instances (restriction !ex:b (some-values-from !ex:c))) (!ex:c1)

In this example, with the addition of a cardinality restriction we
can push the value down from the super to the subproperty.

(with-ontology has-same-value ()
((object-property !a)
(object-property !b (super !a))
(class !c :partial)
(equivalent-classes
(intersection-of !c (restriction !a (some-values-from !c)))
(intersection-of !c (restriction !b (some-values-from !c))))
(individual !c1 (type (intersection-of !c (restriction !a
(cardinality 1)))) (value !a !c1)))
(describe !c1))

Individual http://example.com/#c1
All Types: ex:c
Direct Types: ex:c
!ex:a: !ex:c1
!ex:b: !ex:c1

-Alan

[Alan Ruttenberg]

[Resend of a previous private thread]

I'm guessing the main list doesn't care so much about the specifics
of the DL.
Would you prefer us to come to some conclus on the logic off-line and
then
present something back to the list, rather than confuse them with
upside-down
capital 'a's and lumps of lisp?

So, let's say we have:

has_participant
domain(has_participant Process)
range(has_participant IndependentContinuant)

utilizes_instrument < has_participant
domain(utilizes_instrument E.realizes InstrumentRole)
range(utilizes_instrument E.bears InstrumentRole)

InstrumentRole < Role
InstrumentRole r1
InstrumentRole r2
Instrument i
Process p

p has_participant i
p realizes r1
i bears r2
p ¬realizes r2
i ¬bears r1

See that the role instance on the process and on the instrument are
different.
If we use the kind of rule/inference that looks at the roles filled
on the
fillers of has_participant but does not look at the individuals
involved, we
accidently infer that "p utilizes_instrument i", when in fact the
underlying
individuals explicitly rule this possiblity out.

The correct inference is reached if we have a rule of the form:

p realizes r and p has_participant i and i bears r => p
utilizes_instrument i

However, as this expression uses r in two places, I am not sure that
we can do
this in owl 1.1 - perhaps something with ObjectExistsSelf on the role
instance and a role-chain can fix it. However, I think the roles you
can use
in a role-chain are restricted, so may not allow this. I'll give it a
go in
protege 4.

Matthew

Matthew

[Alan Ruttenberg]

[Resend of a previous private thread]

Right, I've attached a mini-ontology with the different arrangements of
individuals, classes, properties. I've had a go by hand, adding in role
chains and ObjectExistsSelf axioms, and as far as I can tell, it is not
possible to express what you wish to state in owl 1.1, because of the
use of
a single role individual on the process and the instrument.

However, I have a feeling we could spend a week playing with syntactic
variants here and not get anywhere concrete. Shall we punt this to
the owl
mailing list?

Matthew