Jeremy Carroll: - Definition: Let T be the mapping from the abstract syntax to RDF graphs from Section 4.1. Let O be a collection of OWL DL ontologies and axioms and facts in abstract syntax form. O is said to be imports closed iff for any URI, u, in an imports directive in any ontology in O the RDF parsing of the document accessible on the Web at u results in T(K), where K is the ontology in O with name u.

Alan Ruttenberg: responding to Jeremy saying that we should leave this to the caching mechanism. The reason that I would like to have "location punning" on names is that I would like to use different tools at one time.

Peter Patel-Schneider: this is because some annotations are semantic extensions, that should be keeped separate from other annotations.

Sebastian Brandt (guest): I have another use-case: I have some annotations that are just user documentations, some that contain "code" that is used by the application, and even some that are generated automatically by my applications.

preference in producing an overview doc that is between OWL 1.1 overview and OWL overview

Sandro Hawke: (rather contovercially) I hope the Semantic Web survives RDF. [ That is, the goals of Semantic Web are important. RDF may not be the best way to meet those goals. I hope those goals are met, even if it mean moving beyond RDF. ] [Scribe assist by Sandro Hawke]

NOTE (guest): Because in OWL Full datatype properties are a subclass of object properties, an inverse-functional property can be defined for datatype properties. In OWL DL object properties and datatype properties are disjoint, so an inverse-functional property cannot be defined for datatype properties. See also Sec. 8.1 and Sec. 8.2. [Scribe assist by Jeremy Carroll]

Markus Krötzsch: in foaf people use b-nodes rather than individuals, so the easy key might not solve the foat problem

Bijan Parsia: What I meant: It's a bad idea to, in committee, to significantly and somewhat arbitrarily increase the implementation burden. But without adding a hook, implementors *can't* (compatibly) experiment

Bijan Parsia: So, let's add the hook and be cautious about how we fill in the hook

stall poll 1: many +1, no -1, four 0

s/stall/straw

straw poll 2: (all) +1

straw poll 3 (about 2-b): many +1, two (conditional) -1, six 0

straw poll 4 (n-ary datatype): twelve +1, six -1, five 0

straw poll 5(easy key): 22 +1, one -1

Boris Motik: one profile proposal: a set of default profiles and allowing users to have arbitrary profiles

Slide: Applications of partial dl semantics

Bijan Parsia: It has more fine grained analyses, including in terms of AL, ALHF, SHIF, and SHOIN, on the one hand, and RDFS(DL), DL-Lite, EL++, and "non-tractable"

Bijan Parsia: It also discusses "repairable" OWL Full ontologies and (sketchily) how the non-repairable ones fall into OWL Full

Bijan Parsia: It's not at all clear to me how to map the analyses in that paper to OWL Prime (in part because I don't understand OWL Prime)

James Hendler: paper also took a DL approach to the world, the raw data showed the great bulk of the stuff out there, pre-change, was low expressivity RDF or RDF with a little OWL - it's where the RDF 3.0 proposal came from

Bijan Parsia: In fact, I don't see that anything I said had anything to do with what fell into RDFS or not

Bijan Parsia: The repair had mostly to do with the nominally owl full documents.

Bijan Parsia: In fact, if you look at table 2 and table 3, the second part of your assertion is at least questionable

Bijan Parsia: """Of the 307 OWL Full documents that can be patched, 63% become OWL Lite documents, and just 37% become OWL DL. Two observations can be made. First, The majority (91%) of the OWL Full documents (from Table 2) can be turned into a decideable portions of the languages by adding type triples. Secondly, the majority of RDFS documents (95%) can transition to OWL easily by adding type triples and use OWL vocabulary instead of RDFS vocabulary."""

Slide: support semantics beyond owl prime

Jeremy Carroll: question about example being supported directly in the future

Slide: implementation in rules

Post Presentation Q & A

Ian Horrocks: the tractable fragments doc describes fragments with known database mapping. wondering why you didn't choose one of those

Zhe Wu: we started by asking existing customers what they needed. most told us they just needed simple extension into owl from rdf

Zhe Wu: ... pretty much the approach was driven by customers and need to implement efficiently

Ian Horrocks: but, customers said you needed something small (rdf + a bit) which is exactly what the fragments are. instead you chose a large fragment and implemented incompletely

Zhe Wu: so far, for those other fragments we have not found a complete rule set (except PD*)

Sandro Hawke: (I find the "small fragment" vs "large fragment" language very confusing, because I don't know what the metric is. large number of terms? large number of users? large implementation effort needed?

Discussion of PD* soundness and completeness in a rule based implementation, which scribe didn't capture

James Hendler: fwiw, those fragments got little or no traction with the folks I consult for - they care about parallelizability and performance over the more understood stuf - their work is largely heuristic anyway

Ian Horrocks: the problem with PD* is that it doesn't implement a subset of OWL, it implements PD*

Alan Ruttenberg: I hear interest in co-ordinating on database fragments with Oracle

Bijan Parsia: to standardize a fragment, we need a well defined specification that we can all understand

Uli Sattler: Zhe, I might have sounded hostile, which wasn't intended: some of us simply have a specific reading for certain words like "reasoner", and I couldn't see how this could be possible.

Uli Sattler: Zhe, also, if you want to see how IntersectionOf can be simulated with someValues and AllValues, ask Carsten.

IRC aside on specifications, definitions, and implementations

The following IRC conversation happened in parallel to the in room verbal conversation and some other IRC exchanges. It continued until Ivan the point in the minutes where Ivan requests an end to side conversations (just before Semantic Subsets)

Uli Sattler: Jim, I appreciate this -- but "reasoner" was used on Zhe's slides, and i simply wanted to know in which sense.

James Hendler: Bijan - agree with needing a spec, but I'd point out most programming languages get by just fine with operational semantics - in fact, since you implement Pellet in JAva, in a certain sense you're trusting that they get it right in some sense -

Uli Sattler: Jim, I guess what we would like to see is a consensus of what we mean by "Tool/reasoner X supports feature Y"

Bijan Parsia: First, I'm not saying anything about the specification style....but at the moment we don't have a clear spec. I don't know where to start other than by looking at Oracle's implementation

James Hendler: Uli, how do we show "Java" supports "begin/end loops"? that seems to be something in the real world that we could model for some (not all) of our work

James Hendler: this is the point!! thw Owl language features all have operational semantics that are good enough for many people in many situations - so when Oracle says we support X, why do we need more than that

Bijan Parsia: Second, there are differences between programming languages and ontology/data modeling languages. I hear your point, but find the analogy rather unconvincing.

Uli Sattler: Jim, I would never dream of trying to do this - but i would like to try to say what it means for a reasoner to support feature X

James Hendler: What I'm arguing is that RDFS 3.0, or OWL Prime, might be better looked at less as ontology languages (leave that to OWL DL) then as useful data analysis languages

James Hendler: Bijan, that is either easily defined, or can be left to philosophers trying to write PhDs, in the real world, lots og languages work this way - but if you want something better - okay, we'll use SCL

Uli Sattler: and whether you "apply" it to all named individuals or to *all* individuals

James Hendler: but anyway, the point I'm making is not to oppose model theory - but the problem is to get the model heory right we have to put restrictions on the languge that some of us cannot live with easily

James Hendler: Bijan - you're arguing circularly - but I can cut through it - I have created a wiki page with a description of exactly which language features I want to include - how to define it in a spec is something I'm happy to discuss

Sandro Hawke: Jim, we're talkin in the room now, and need to focus on this discussion in the voice channel, so no more chatter on IRC, please.

Ian Horrocks: ... it has been a success for owl that interoperability is so good, considering

Jeremy Carroll: responding to standardizing tools - yes. there is value to user if they know different tools perform the same

Jeremy Carroll: ... this wg could provide appropriate conformance levels where vendors and user community come together

Jeremy Carroll: ... clear that motivations from academic community are useful, but they aren't the only motivations

Sandro Hawke: +1 Jeremy: there is real value to the customers in knowing that a set of products will all do (at least) the same thing. It would be a service to the community for this WG to provide that.

Boris Motik: wants to distinguish declaredAs from type. Since there is no notion of typing of RDF, things become problematic, especially with imports, e.g, do we need to re-declare when importing? In the owl10, there was no difference between "class" and "declaration"

Alan Ruttenberg: there wasn't even a notion of an ontology containing an axiom

Bijan Parsia: there is something about documents and ontologies (how to get one from the other)

Jeremy Carroll: suggests to use lateral thinking to solve this: use a new way of imports, namely one where we put import statements at the top of our ontologies and then all declarations will be there!

Boris Motik: seems to agree that this will help tools - if I knew what the type of things are, I could use streaming mode

Bijan Parsia: if they come late, they can still be useful (eg to find typos), but they are most useful at the top

Jeremy Carroll: suggests that we can do this via searching & process imports first

Boris Motik: asks whether typed vocabulary will be obsolote - if yes, we can re-use it

Boris Motik: we can merge the notion of typing and declarations, but cleanly

F2F2

Peter Patel-Schneider: F2F2 will be on April 3 and 4, in the Washington DC area, venue to be determined. OWLED might be in the area, but perhaps not. One possibility is to make use of NIST, but access is restricted