New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Coining and applying dcam:rangeIncludes
#43
Comments
Using the DCAM namespace essentially makes this a modification to DCAM. Should we look at what it does to the DCAM model? Should we update the DCAM documentation to include this? |
@kcoyle Instead of starting an entirely new namespace, I suggest we simply rename Section 8 of DCMIMT so that it does not imply that that these are "Terms related to the DCMI Abstract Model", then annotate or even deprecate the DCAM specification itself, though that is a different discussion. |
STRAW POLL ON USING
|
STRAW POLL ON LITERAL RANGESDo you agree with not changing |
STRAW POLL ON DEFINITION OF
|
STRAW POLL ON ALTERNATIVE DEFINITION OF
|
STRAW POLL ON DEFINITION OF
|
rdfs:range with rdfs:Literal statementsAs far as I see, the properties used with rdfs:Literal are the date properties and the titles. In both cases I would prefer rangeIncludes, because with rangeIncludes we would recommend to use a literal value but also allow people to use URIs if it is necessary. |
Definition of rangeIncludesI prefer Antoine's definition. So the definition will be |
The statements that begin "class of which" are very hard to parse - I have to read them multiple times and still they don't stick. (I think this is an English problem - I can see how it might work ok in other languages.) We need something more like the schema.org statement which is direct, not contorted. Other suggestions: |
Maybe I'll have a position that will cut the discussion on "my suggestion" short...
I am still convinced that my suggestion is an improvement over the original ISO one "class of which a value described by the term is an instance", which is not only quite messed up wrt its English, but also wrt its metamodeling parliance.
*But* the ISO definition shouldn't be the based for rangeIncludes, in my current view. I prefer the Schema.org definition (or @kcoyle's attempts), because it conveys that the property comes with a range **expectation**. Adapting the ISO definition (with the original wording or mine) fails at this because of the 'may' in it. This is essentially the reason why I'm down-voting the suggestion at #43 (comment)
Note that I'm not sure the Schema.org definition would be my final choice, at this stage. Ideally I would also like that we convey the **expectation** even when literals are used.
This was the essence of the second part of my suggestion for dct:rights at
#30 (comment)
I am perhaps naive/idealistic, but if there would be a way to convey this message I think it would be great in terms of implementation guidance.
As for my reluctance to agree with the blanket replacements or confirmations of rdfs:range statements at
#43 (comment)
#43 (comment)
This is because I would prefer that we go through all these individual properties and make the decision for each one. It shouldn't take too much time, we would be certain about what we do, and we might get some very valuable insight if there's an issue for a property in that process.
|
Thanks, @aisaac. I'm going to add something here which we can decide to ignore... the use of rangeIncludes/domainIncludes to my mind is making a false equivalence or extension of rdfs:range/domain. In fact, what we are doing is the opposite of RDF: Neither of these acts as a constraint on the domain or range of a property, and neither is advice to the metadata creator (although we almost always read it that way). What schema.org does is it uses xIncludes to advise metadata creators on best practices for properties. It also treats those choices as OR rather than UNION. (I may have that wrong, my formal logic is minimal.) This is really unrelated to the semantics of RDF domain and range. I say this because I think we want to be clear that we are providing something very different from RDF's domain and range. I would like to see the RDF world adopt something other than xIncludes, and I think we should think about this as we do more work on application profiles. I would like to have properties that have the meaning of "suggested value types" "suggested class inclusion" or something like that, and that are clearly differentiated from domain and range. Among other reasons, there may be cases in which you want to define both (dubious? thinking ...) All of this to say that I do want us to use "suggested" or "expectation" in our definitions because that is the actual meaning of the property. We do not want to imply that any inferencing on these values would produce the kind of semantics that one would expect with domain and range, including their use in query (SPARQL). |
+1 |
Relates a property to a class that is an expected type for the value of the property. |
rangeincludes: The value of this property may be an instance of this class It is recommended that values of this property be members of this class. |
rangeIncludes: Instances of this class are appropriate as values for the property. |
Trying to keep the notion of expectation in @kcoyle comment above, but fitting to the case of several rangeIncludes: |
My rewording of @aisaac's above proposal:
|
@osma I still would fight for some idea of 'expectation' to be included. |
@aisaac I don't quite follow...you can't just turn the parts of a statement like this into their negatives and retain the meaning. Saying that "X is an appropriate value type for the property Y" does not entail that "everything not X is not an appropriate value type for Y", just like "Socrates is human" does not entail "everything that is not Socrates is not human". I'm thinking about this from an Open World Assumption perspective, where each statement represents a part of the truth, but does not preclude other similar statements to be true as well (as long as they don't contradict each other). So each rangeIncludes statement should be true on its own, irrespective of other rangeIncludes statements that may apply to the same property. Maybe the wording I suggested does not convey this in an ideal way, but that's what I was aiming at. Regarding rdfs:range, I consider it quite strong, despite it not being intended for validation. With "Y rdfs:range X", every value that is used with the property Y can be inferred to be an instance of X. This usually means that there can be only one value for rdfs:range for a particular property. For example, with |
@osma I beg to disagree in this specific case. Having a definition reading "Here's a property P. Class C is appropriate for P" is quite different from "Here's Socrates. Socrates is a human". |
@aisaac Point taken. I guess we have to find another formulation that cannot be misinterpreted that way. How about:
|
@osma I miss very much the notion of 'expectation' or 'suggestion' in this. 'May' could be anything... |
I like Tom's suggestion: rangeIncludes: Instances of this class are appropriate as values for the property And we could substitute "suggested" for "appropriate". I agree with Antoine that "appropriate" has the sense that anything else is "inappropriate" which is very close to "not valid" in meaning. Not being suggested just means that it isn't preferred. In fact, we could use "preferred": rangeIncludes: Instances of this class are preferred as values for the property I'm not happy with the "relates" statements. Every property "relates" so that isn't necessary. |
|
PROPOSED
|
PROPOSED
|
PROPOSED
|
PROPOSED
|
PROPOSED
|
PROPOSED
|
PROPOSED
|
Resolved! |
This was not closed in fact, and I'm not sure it shall be. Out of the initial points, we have agreed on having |
Closed - discussion continues in Issue #59 |
@niklasl Am reopening this issue in light of schemaorg/schemaorg#3442, where @hoijui suggests mapping |
I commented there, and in fact I don't think that the differences are all that subtle. schema.org defines domains and ranges for its xIncludes properties that are quite specific to schema. DC's properties have no domains or ranges defined, making them wide open in terms of those aspects. In RDF terms, that's really apples and oranges. As I say there:
|
My main motivation is, to aide ontology designers (like me) as much as possible, to figure out which they should use, As I understand right now (after @kcoyle s explanations), the |
Yes, this difference is crucial. The DCAM variants are intentionally unconstrained, so they cannot be subproperties of the more constrained Schema.org variants. It would be great if Schema.org defined those to be Process-wise it may be considered "backwards", but such is occasionally the case (and in the future more commonly so, I hope). An "application ontology" defines properties for specific needs. Sometimes those needs would be great to generalize just a tiny bit, defined in a "shared ontology", which the application-centric one can then, as a supportive act of the general case, formally align to. (I believe this is quite like what we hope for with openWEMI, for instance.) |
Now I have to rebut my own comment because openwemi is using the same class names as FRBR. I still think that will work because FRBR classes are not actually in use. The words, especially "Work", are common and not exclusively property names, like "rangeIncludes". However I still think that thought must be given to how humans AND machines act on defined elements, especially since there is an explosion of terms being defined in the RDF space. |
But the schema:Property and schema:Class classes that are suggested domain and range of their ___Includes properties are declared as equivalent to rdfs:Class and rdfs:Property. So
is not particularly limiting. I find it hard to think of uses of the dct: properties that wouldn't honour that suggestion. That said, I wouldn't mind the superabundance of caution that the rdfs:subPropertyOf provides, because many things that I find hard to think of turn out to exist. |
Both |
@hoijui To use a turn of phrase from Alistair Miles, I think of But what if a URI used as the object of a Put another way, would we really want to implicitly limit I see utility in a notion of |
@tombaker @hoijui I can understand Tom's view that "limiting" to classes (aka URIs) is a limitation, although his argument could also be read as "no problem, because anything can be a class" and "this only matters when doing inferencing." But I am still bothered by the use of the rangeIncludes/domainIncludes properties, which to me imply a kind of formality related to the RDF concept of range (which does require a class value).
schema's is:
The former reads like a note for humans, the latter is written as a formal statement. How does the human-facing definition interact with the RDF formal definition? I think the schema's definition can be read as potentially driving an application, whereas the DCTerms definition reads like a note for humans. It may be subtle, but there is a difference. Schema is an "application vocabulary" as @niklasl calls it, and a vocabulary that is very self-contained, defining its own elements for Class and Property (as @philbarker shows). The "pseudo-formality" of schema.rangeIncludes and domainIncludes may allow or imply some kind of processing on values for those creating schema metadata. I see DCTerms as being less prescriptive. If, in most cases, DCTerms is silent on a formal constraint on values, then I would prefer that this be expressed in something that a person would read as a note without the baggage of the schema usage. Given that most users of these vocabularies will not see the definitions for rangeIncludes and domainIncludes in schema and DCTerms, they would logically assume that they are the same. Because they are not I think that using the same property names is confusing. Actually, that is precisely why we are here. |
Given that most users of these vocabularies will not see the definitions
for rangeIncludes and domainIncludes in schema and DCTerms, they would
logically assume that they are the same. Because they are not I think that
using the same property names is confusing.
Yes! This is why I was surprised. The design for schema.org was based on
deployment experiences with RDFS and a concern that using the W3C
rdfs:range and rdfs:domain definitions as-is would be an engine for
generating needless "middleware" types in the (rather large) schema.org
type hierarchy. Instead of making a "this is Schema.org alternative version
of rdfs:range and rdfs:domain" weird situation we went for documenting a
couple of alternative RDFS-like (RDFS-extending) properties. Which was how
RDFS was supposed to be extensible since 1998 or so.
I think part of the source of confusion is that there are two views you can
take on what the Schema.org datamodel doc says about rangeIncludes and
domainIncludes.
You can take the static "schemas as they are right now" view, which is how
most RDF/S works when considered formally. Or you can take a more social
"we know this stuff is going to be changed over time view", which is how
most actual schemas work, especially big ones like schema.org and modest
sized ones like FOAF and DC.
The datamodel page https://schema.org/docs/datamodel.html says
1. each property may have one or more types as its domains. The property
may be used for instances of any of these types.
2. each property may have one or more types as its ranges. The value(s)
of the property should be instances of at least one of these types.
This gives the impression you have the "license to infer", when in fact a
more temporal perspective would caution "so long as the schemas don't get
changed...".
Imagine it is Tuesday and an imagined mediaFoo property has BarMedia and
BlahMedia as its expected types, ... (i.e. mediaFoo is a Property, and we
would say both "schema:mediaFoo schema:rangeIncludes BarMedia" and also
schema:mediaFoo schema:rangeIncludes BlahMedia".
And so if we find some data on Tuesday using Tuesday's schemas would allow
you to conclude "well it ought to be a BarMedia or a BlahMedia or both"
whenever you see some value for the mediaFoo property.
And if someone writes software on Wednesday assuming that schemas never
change, they might bake assumptions into code along those lines.
But what happens on Wednesday when XYZMedia is added to the imaginary
schema.org terminology in this area, and also added to the definition for
schema:mediaFoo?
Thursday's real world data could use that and if we on Friday see data like
item_123414 schema:mediaFoo item_61712271 what can we conclude? That it's
either going to be a BarMedia or a BlahMedia or an XYZMedia (or there's a
bug, or that the schemas have evolved even further, or that someone is
using terminology in an unusual way. Doing so btw is not a crime! Tom has a
great paper on this -
https://www.dl.slis.tsukuba.ac.jp/ISDL97/proceedings/thomas/thomas.html -
and it fits with our experience at Schema.org. People try out new idioms
and report back and sometimes they fizzle out, and sometimes they get added
to the documentation - "paving the cowpath".
Framed in these terms the two flavours of rangeIncludes and domainIncludes
may be closer than it seems.
The schema.org documentation emphasises the conclusions you could draw if
you knew you weren't going to be messed with by schema changes. The DC
version seems a lot scruffier but by using the exact same property names
(and RDFS-style naming) probably isn't as far from RDF/S's underlying
types-and-instances underlying datamodel as we might think. People will
recognize their distinctive names and probably assume they basically do the
same thing, even if they don't.
p.s. this is not a criticism, these things happen - https://schema.org/title
vs dc:title etc. and there are many other name clashes between popular
namespaces. FWIW 13 years ago I started mapping out these clashes, see
https://github.com/danbri/Zoo/blob/master/zoo.foaf.tv/zoo/master.txt
https://github.com/danbri/Zoo/blob/master/zoo.foaf.tv/zoo/zoo_manifest.txt
- very out of date. I think the difference here is that the clashing
vocabulary is two different versions of the vocabulary-describing
infrastructure. And we know from the different flavours of OWL
(Lite/Full/DL etc) that people get very confused when different
interpretations are applied to the same building blocks.
…On Mon, 15 Jan 2024 at 17:16, Karen Coyle ***@***.***> wrote:
@tombaker <https://github.com/tombaker> @hoijui
<https://github.com/hoijui> I can understand Tom's view that "limiting"
to classes (aka URIs) is a limitation, although his argument could also be
read as "no problem, because anything can be a class" and "this only
matters when doing inferencing."
But I am still bothered by the use of the rangeIncludes/domainIncludes
properties, which to me imply a kind of formality related to the RDF
concept of range (which does require a class value).
I think it is significant that DCTerms definition for rangeIncludes is:
A suggested class for values of this property.
schema's is:
Relates a property to a class that constitutes (one of) the expected
type(s) for values of the property.
The former reads like a note for humans, the latter is written as a formal
statement. How does the human-facing definition interact with the RDF
formal definition? I think the schema's definition can be read as
potentially driving an application, whereas the DCTerms definition reads
like a note for humans. It may be subtle, but there is a difference.
Schema is an "application vocabulary" as @niklasl
<https://github.com/niklasl> calls it, and a vocabulary that is very
self-contained, defining its own elements for Class and Property (as
@philbarker <https://github.com/philbarker> shows). The
"pseudo-formality" of schema.rangeIncludes and domainIncludes may allow or
imply some kind of processing on values for those creating schema metadata.
I see DCTerms as being less prescriptive. If, in most cases, DCTerms is
silent on a formal constraint on values, then I would prefer that this be
expressed in something that a person would read as a note without the
baggage of the schema usage.
Given that most users of these vocabularies will not see the definitions
for rangeIncludes and domainIncludes in schema and DCTerms, they would
logically assume that they are the same. Because they are not I think that
using the same property names is confusing. Actually, that is precisely why
we are here.
—
Reply to this email directly, view it on GitHub
<#43 (comment)>, or
unsubscribe
<https://github.com/notifications/unsubscribe-auth/AABJSGOJOKE3RW44WUHLNK3YOVQAJAVCNFSM4FK3DQJ2U5DIOJSWCZC7NNSXTN2JONZXKZKDN5WW2ZLOOQ5TCOBZGI2TIMRYGIZQ>
.
You are receiving this because you were mentioned.Message ID:
***@***.***>
|
Uff... Is it even an option, to change the names of the two DC properties (as I understood, that some of you think that might be a good way to go)? |
@hoijui As a point of procedure: to follow our namespace policy, we would not change the names of the two DC properties. However, we could in principle create new properties under a different name, use the new properties instead of the existing properties, and mark the existing properties as deprecated. |
Issue 32: "Broken ranges? has generated some great discussion, covering among other things the history of how
rdfs:domain
andrdfs:range
ended up being defined as they currently are. This was also discussed in the June 26 telecon. It looks like we have converged on the following approach:Coin
http://purl.org/dc/dcam/rangeIncludes
, e.g., as defined in the current ISO draft:Class of which a value described by the term may be an instance.
Coin
http://purl.org/dc/dcam/domainIncludes
:Class of which a resource described by the term may be an instance.
Substitute
dcam:rangeIncludes
forrdfs:range
(anddcam:domainIncludes
forrdfs:domain
) for all properties except for properties with a range ofrdfs:Literal
(which will continued to userdfs:range
).Note that the definition of
dcam:rangeIncludes
proposed here is only slightly different from that ofrdfs:range
("class of which a valued described by the term is an instance"). For comparison, see the Schema.org definitions [1,2].Note that the definitions of
rangeIncludes
anddomainIncludes
would be included in ISO 15836, but as part of Section 3.1 ("Terms and definitions"), where they would be defined in words only (i.e., no URI), and not in Section 3.3 ("DCMI properties"), which lists properties of the/terms/
namespace with their URIs.2018-07-20 edit: This posting conflates several issues that I would like to split out into separate questions below.
[1] https://meta.schema.org/rangeIncludes
[2] https://meta.schema.org/domainIncludes
The text was updated successfully, but these errors were encountered: