Supporting DL reasoning rather than generic reasoning.
General or ontology tools?
--> OWL people main customers.
for DIG 2.0:
use OWL XML schema as much as possible.
Publish DIG 2.0 in its own namespace and just use XSLT.
(Communicate with authors of OWL-XML.)
This solves a lot problems with functionality additions.
XML-schema datatypes already in OWL.
Unary ok, but not n-ary. Postpone n-ary case for the moment.
Follow suggestion in ID paper.
Copy SOAP (new version). Apache Xerces. (SB.)
Result v results -> result
Response v responses -> response
Query everything and flag whether you want to reason or not.
This means keep track in the reasoner of the asserted stuff.
Allow client to ask for TBox in normalised form
. (Eg absorbed.)
The reasoner is free to answer back with the original kb.
ID: strive for regularity
. This can require extra effort, but might be worthwhile.
Agreement on at least looking into all possible variations of verbs and constructs and then see what has to be in.
Attribute values. We can assert that Mary's age is 45 but we cannot ask Mary's age.
. OWL does not support it. Add functionality to switch it on and off.
Make clear this not OWL but using it to communicate with DL reasoners. Default not on but can be switched on. Or also make UNA relative to namespaces (IH). Maybe a feature too far for the moment.
kb_uri. (Implementation: just ask if Thing is equivalent to Nothing.) Issues relative to ABox reasoning.
. Hard from a reasoning pont of view. Regularisation issue again.
Anonymous resources. No way of preserving the RDF B-node identities. Not wise pushing them into DL reasoner.
more interesting. Mark them out as such using a standard URI (as in OWL API). Thus Skolemise with well-defined spec
would do. Both system and client can generate identifiers for anonymous individuals. Use known algorithms to minimise possibility of name clashes. They will be treated specially by system and can be returned to queries. The client will have to handle the answers appropriately.
Add at later stage and make sure no clash with above treatment of anonymous individuals.
Parameters for reasoning behaviour
Get set of options from reasoner. Not for common options, which should be general names, but ok for lower level options. Problem is that different implementations can use lower level to control general options. Thus try to identify general options and allow for a back door allowing users to tweak beahaviour. Use property sets.
(eg is kb uri valid?).
Multiple kbs managements. Problem is that we might move from a reasoner interface to a reasoner service.
In industrial settings one needs to attach metadata to kbs. Provide this at least.
Cannot use the fact that OWL ontologies have names because of incremental tells.
Keep on using generated kburis. Recommend that never
a kburi is reused. Racer seems to violate this.
Ability to query metadata of kburi (last change, when created, etc). Make it optional.
OWL schema very large (eg imports etc).
We want to pick and choose the constructs we want.
Internal times. An extra attribute in response. Or statistics.
Agreed on general requirement for performance information, but we will come back on actual syntax.
Serialise reasoner content
Difficult to make it generic. Enough to reload reasoner from client. Save and restore. Problem is that we assume the same reasoner is used. Complexity issues. Danger is we try and do too much.
Tighten up specification of exiting verb. Again use property sets.
Use v deploy. Since we expect use of this we will test performance on fact++. Problem is all the options for compressing.
Less needed if kburis unique.
. Typical scenario one writer many readers. But we can do that with a service on top. Maybe the multiuser scenario does not make sense for DIG. Ask Cerebra people about their requirements.
Removing information from kb
Easy to do in the interface. Less so at the reasoner level. Support untell
but not retract
. Tricky to specify so better be on the safe side and make it as easy as possible for implementors. More like a text editing operation than anything else. This requires identifiers for atomic tells which is problematic. String matching also not very good, but we have to live with that.
To be discussed further.
Checkpoints and rollback
Similar to the point above but easier to implement. Would make query of premises easier.
Put an extra argument in ask containing the temporary assertions.
At least qualified cardinality restrictions and allDisjoints.
Having moved to OWL anyway let us postpone further extensions.
In general, we can go ahead and make them de facto standard.