Counting and Sets in OWL OWL augments restrictions with a full set-theoretic language, including intersections, unions, complements Using these, we combine

Counting and Sets in OWL OWL augments restrictions with a full set-theoretic language,

including intersections, unions, complements

Using these, we combine

restrictions (e.g., the set of planets that go around the sun and have at least 1 moon)

the classes used to define restrictions (e.g., a Vegetarian is someone who eats food that is not Meat)

OWL also includes restrictions that refer to cardinality,

referring to the number of distinct values for a given property some individual has

We can then describe, e.g., “the set of planets that have at least 3 moons”

Reasoning with sets must cope with the following fundament aspects of the Semantic Web

Open World Assumption (a consequence of the AAA slogan) There could always be something new that someone will say; we

must assume that there is always more info that could be known

Nonunique Naming Since the speakers on the Web won’t necessarily coordinate their

naming efforts, the same entity could be known by more than one name (URI)

Unions and Intersections All set operations can be used on any class definition, including

named classes and restrictions

They use the collection (list) constructs of RDF

U1 a owl:Class;

owl:unionOf ( ns:A ns:B … ).

I1 a owl:Class;

owl:intersectionOf ( ns:A ns:B … ) .

The intersection/union of 2 or more classes it itself a class

Represented by either naming the class or by defining an anonymous class

An anonymous class can be used again if named using owl:equivalentClass

bb:MajorLeagueBaseballPlayer owl:equivalentClass

[ a owl:Class;

owl:intersectionOf

( bb:MajorLeagueMember bb:Player bb:BaseballEmployee ) ] .

Natural language descriptions often have a notion of intersection built in

“All planets orbiting the sun” is the intersection of all things that orbit the sun (a restriction) and all planets

:SolarPlanet a owl:Class;

owl:intersectionOf (

:Planet

[ a owl:Restriction;

owl:onProperty :orbits;

owl:hasValue :TheSun] ) .

The set of major league baseball players is the intersection of

all things that play on a major league team (someValueFrom restriction) and

baseball players

:MajorLeagueBaseballPlayer a owl:Class;


:BaseballPlayer


owl:onProperty :playsFor;

owl:someValuesFrom :MajorLeagueTeam] ) .

Example: High-Priority Candidate Questions Earlier defined

a class of candidate questions based on dependencies on selected answers

priorities for the questions

Now use set constructors to combine these to form a class of candidate questions of a given priority

Repeat here the description of SelectedAnswer that classifies a dependent question as EnabledQuestion

q:SelectedAnswer rdfs:subClassOf

[ a owl:Restriction:

owl:onProperty q:enablesCandidate;

owl:allValuesFrom q:EnabledQuestion] .

Define a class of questions we’re ready to ask based on 2 criteria

They’ve been enabled by the description above

They have high priority

Do it with an intersectionOf constructor

q:CandidateQuestion owl:equivalentClass

[ a owl:Class;

owl:intersectionOf

( q:EnabledQuestion q:HighPriorityQuestion )] .

Or we could make a more relaxed description for candidate questions and include medium-priority questions

q:CandidateQuestion owl:equivalentClass

[ a owl:Class;

owl:intersectionOf

( q:EnabledQuestion

[ a owl:unionOf

( q:HighPriorityQuestion

q:MediumPriorityQuestion )] )] .

Closing the World Note the impact of the Open World Assumption on set operations and

counting

Even the notion of set complement is subtle

Say, based on its absence, that something isn’t a member of a set But then find that it is

But there are ways to assert in OWL that certain parts of the world are closed

Make inferences involving complements or counting much clearer

Example: James Dean made only 3 movies We know this; he’s been dead for 50 years

Enumerating Sets with owl:oneOf In the James Dean example, needn’t reject the Open World

Assumption

Just need an enumeration of all the members of a given class (James Dean movies)

Enumerate the members of a class with the owl:oneOf construct

ss:SolarPlanet rdf:type owl:Class;

owl:oneOf ( ss:Mercury ss:Venus ss:Earth ss:Mars

ss:Jupiter ss:Saturn ss:Uranus

ss:Neptune ) .

This class contains 8 individuals and no others

owl:oneOf limits the AAA slogan

Nobody else can say there’s another distinct item

So use owl:oneOf carefully and only when the definition of the class isn’t likely to change (or at least not often)

But owl:oneOf places no limitation on the Nonunique Naming Assumption

Makes no claim about whether, e.g., Mercury might be the same as Venus

Combined with owl:someValuesFrom, owl:oneOf provides a generalization of owl:hasValue

owl:hasValue specified a single value a property can take

But owl:someValues from combined with owl:oneOf specifies a set of values a property can take

Challenge In a dialogue with Rimbaud, Rocky used the fact that

James Dean made only 3 movies and a process of elimination

to determine what movie Rimbaud saw

How to represent this in OWL?

Solution Define the class of James Dean movies as

:JamesDeanMovie a owl:Class;

owl:oneOf ( :Giant :EastOfEden :Rebel ) .

As usual, we define the meaning of owl:oneOf in terms of the inferences that can be drawn from it

There are several

First, can infer that each instance listed in owl:oneOf is indeed a member of the class

Given the above, can infer

:Giant rdf:type :JamesDeanMovie .

:EastOfEden rdf:type :JamesDeanMovie .

:Rebel rdf:type :JamesDeanMovie .

But owl:oneOf also asserts that these are the only members

In terms of inference, if we assert that some new thing is a member of the class, it must be owl:sameAs one of the members listed in the owl:oneOf

list

In our example, if someone introduces a new member of the class

:RimbaudMovie rdf:type :JamesDeanMovie .

can infer that :RimbaudMovie is owl:sameAs one of the movies mentioned

So far, we’ve expressed inferences in terms of new triples inferred

But here the inference tells that some triple from a small set holds (don’t know which)

Can’t assert any new triple

To do the elimination in OWL, must be able to say that some individual is not the same as another

Differentiating Individuals with owl:differentFrom Because of the Nonunique Naming Assumption, when we want

different things, must name things that are explicitly different

For this, OWL provides owl:differentFrom ss:Earth owl:differentFrom ss:Mars .

owl:differentFrom supports several inferences when used with other constructs like owl:cardinality and owl:oneOf

Challenge 28 Use OWL to model the dialogue between Rocky and Rimbaud so

OWL can infer that Rimbaud saw Rebel

Solution At the beginning of the dialogue, Rocky knows that the movie

Rimbaud saw was one of the 3 listed

He guesses Giant. If correct, can assert

:RimbaudMovie owl:sameAs :Giant .

But wrong, so assert

:RimbaudMovie owl:differentFrom :Giant .

Still must guess, this time East of Eden, and again wrong, so assert

:RimbaudMovie owl:differentFrom :EastOfEden .

The semantics of owl:one of and owl:differentFrom now let us infer

:RimbaudMovie owl:sameAs :Rebel .

See Figure 1 for the assertions and inference

Differentiating Multiple Individuals To simplify specification of lists of items all different from one another,

OWL provides 2 constructs used together: owl:AllDifferent, owl:distinctMembers

Specify that an RDF list (i.e., collection) of items are mutually distinct by referring to the list in a triple using predicate owl:distinctMembers

The domain of owl:distinctMembers is owl:AllDifferent

It’s customary for the subject of an owl:distinctMembers triple to be a bnode

[ a owl:AllDifferent;

owl:distinctMembers

( ss:Mercury ss:Venus … ss:Neptune )] .

The following is typical

:SolarPlanet a owl:Class;


owl:oneOf ( ss:Mercury, ss:Venus, ss:Earth, ss:Mars,

ss:Jupiter, ss:Saturn, ss:Uranus,

ss:Neptune )


owl:distinctMembers

(ss:Mercury, ss:Venus, ss:Earth, ss:Mars,

ss:Jupiter, ss:Saturn, ss:Uranus,

ss:Neptune ) ] ) .

This is the same as asserting 28 owl:differentFrom triples, one for each pair of items in the list

For the James Dean movies,


owl:distinctMembers

( :EastOfEden :Giant :Rebel )] .

It’s common to use owl:oneOf and owl:AllDifferent as we’ve done,

to say that a class is made up of an enumerated list of distinct elements

See Figure 2 The list is

constructed with rdf:first, rdf:next, rdf:nil

Cardinality Cardinality restrictions let us express constraints on the number of

individuals that can be related to a member of the restriction class

E.g., a baseball team has exactly 9 (distinct) players

Cardinality restrictions also let us define sets of particular interest—the set of 1-act plays

The syntax is similar to other restrictions—e.g., the class of things with exactly 5 players


owl:onProperty :hasPlayer;

owl:cardinality 9]

Can also specify a lower bound—e.g., those things with at least 10 players



owl:minCardinality 10]

and an upper bound—e.g., those things with at most 2 players



owl:maxCardinality 2]

Cardinality refers to the number of distinct values a property has

It interacts closely with the Nonunique Naming Assumption and owl:differentFrom

Regarding inference,

if we can show that an individual has exactly (resp., at least, at most) n distinct values for a property,

then it’s a member of the corresponding owl:cardinality (resp., owl:minCardinality, owl:maxCardinality) restriction

Similarly,

if we assert that something is a member of an owl:cardinality restriction,

then it must have exactly n distinct values for the property

Similar conclusions follow from restrictions on minimum and maximum cardinality

Challenge 29 Rocky and Rimbaud continue their conversation

Rimbaud: Do you own any James Dean movies?

Rocky: They’re the only ones I own.

Rimbaud: Then you own no more than three movies.

Model these facts in OWL so that Rimbaud’s conclusion follows from the OWL semantics

Solution Need a property to indicate that someone owns a movie

:ownsMovie a owl:ObjectProperty .

In OWL, make general statements about an individual by asserting that they are a member of a restriction class

:JamesDeanExclusive owl:equivalentClass


owl:onProperty :ownsMovie;

owl:allValuesFrom :JamesDeanMovie] .

:Rocky a :JamesDeanExclusive .

Define the class of things that own at most 3 movies

:FewMovieOwner owl:equivalentClass



owl:maxCardinality 3] .

Rocky’s conclusion is the triple

:Rocky a :FewMovieOwner .

This triple can be inferred from the model

All values of property :ownsMovie for Rocky come from class :JamesDeanMovie

There are only 3, all distinct

So Rocky owns at most 3 movies

Figure 3 (next slide) shows the inference

Challenge 30 Model the following in OWL

Rimbaud: How many movies do you own?

Rocky: Three.

Rimbaud: Then you own the one I saw last night, Rebel without a Cause.

Solution Assert that Rocky is a member of the owl:cardinality restriction class

for “the set of things that own exactly 3 movies”

:ThreeMovieOwner owl:equivalentClass



owl:cardinality 3] .

:Rocky a :ThreeMovieOwner .

Now Rocky owns exactly 3 distinct movies

All his movies are members of :JamesDeanMovie

There are just 3 different :JamesDeanMovies

Infer

He owns each of them

In particular, infer

:Rocky :ownsMovie :Rebel .

Figure 4 (next slide) shows the assertions and inferences

Small Cardinality Limits Restrictions of cardinalities to the small numbers 0 and 1 have

special modeling utility

minCardinality 1 Those with some (at least 1) value for the property

E.g., onProperty ownsMovie minCardinality 1 specifies the set of those owning at least 1 movie

maxCardinality 1 Those that, if they have a value for the property, have a unique value

E.g., onProperty ownsMovie maxCardinality 1 specifies the set of those limiting themselves to 1 movie

minCaridnality 0 Those for which a value for the property is optional

Superfluous in OWL semantics (properties are always optional) But the explicit assertion can be useful for model readability

E.g., onProperty ownsMovie minCardinality 0 explicitly specifies the set of those for which owning a movie is optional

maxCardinality 0 Those for which no value for the property is allowed

E.g., onProperty ownsMovie maxCardinality 0 specifies the set of those owning no movies

Set Complement The complement of a class is another class whose members are all

things not in the complemented class

A complement applies to a single class, so define it with 1 triple

ex:ClassA owl:complementOf ex:ClassB .

The complement of a class includes everything in the universe not in that class

E.g., the complement of bb:MajorLeaguePlayer includes not only minor league players but also movies, planets, …

Usually work with the relative complement (e.g., the class of players who aren’t major league players) by combining complement and intersection—e.g.,

bb:MinorLeaguePlayer owl:intersectionOf

( [ a owl:Class;

owl:complementOf bb:MajorLeaguePlayer ]

bb:Player ) .

Using the complement class just here—no need for a name Specified anonymously in bnode notation

Challenge 31 Continue the dialogue with an addition participant, Paul

Paul: I have all James Dean’s movies.

Rimbaud: Do you have other movies too?

Paul: I have some movies that aren’t James Dean movies.

Rocky: You must have at least four movies then.

Model this situation and conclusion in OWL

Solution Define an inverse of :ownsMovie

:ownedBy owl:inverseOf :ownsMovie .

Define the class of all movies Paul owns

:PaulsMovie a owl:Class;

owl:intersectionOf

( [ a owl:Restriction;

owl:onProperty :ownedBy;

owl:hasValue :Paul]

:Movie ) .

Paul owns every James Dean movie: every :JamesDeanMovie is a :PaulsMovie (but possibly not vice versa)

:JamesDeanMovie rdfs:subClassOf :PaulsMovie .

Paul also owns other movies

Capture this in OWL

First note that the following anonymous class includes everything that isn’t a James Dean Movie

[ owl:complementOf :JamesDeanMovie]

Building on this, the following is an anonymous class of all things having some value for :ownsMovie that isn’t a James Dean movie



owl:someValuesFrom

[ owl:complementOf :JamesDeanMovie]]

Finally, we assert that Paul is such a thing

:Paul a [ a owl:Restriction;


owl:someValuesFrom

[ owl:complementOf :JamesDeanMovie]] .

Want to conclude that Paul is a member of a class of people owning 4 or more movies

Remains to define this class

:ManyMovieOwner owl:equivalentClass



owl:minCardinality 4] .

Paul owns all 3 James Dean movies and at least 1 non-James Dean movie

At least 4 in all

So infer

:Paul rdf:type :ManyMovieOwner .

Figure 5 shows the assertions and conclusion

Disjoint Sets Specify that 2 classes are non-overlapping, or disjoint, with

owl:disjointFrom

:Man owl:disjointFrom :Woman .

For any members of disjoint classes, can infer that they are owl:differentFrom one another

Given

:Irene a :Woman .

:Ralph a :Man .

infer

:Irene owl:differentFrom :Ralph .

Challenge 32 Continuing with the dialogue:

Paul: Not only do I have all the James Dean movies, but I also have movies with Judy Garland, Tom Cruise, Judi Dench, and Antonio Banderas.

Rocky: You must own at least seven movies.

Paul: How did you know that?

Rocky: Because none of those people played in movies together.

Model this situation and conclusion in OWL

Solution Express that Paul owns, e.g., a Judy Garland movie by asserting that

he’s a member of the class of things that own Judy Garland movies



owl:someValuesFrom :JudyGarlandMove] .



owl:someValuesFrom :JudiDenchMove] .



owl:someValuesFrom :TomCruiseMove] .



owl:someValuesFrom :AntonioBanderasMove] .

Define the set of people who own 7 or more movies

:SevenMovieOwner a owl:Restriction;

own:onProperty ownsMovie;

owl:minCardinality 7 .

We don’t know that Paul’s a member of this class until we know that all the sets of movies are disjoint

:JamesDeanMovie owl:disjointWith :JudyGarlandMovie .

:JamesDeanMovie owl:disjointWith :TomCruiseMovie .

:JamesDeanMovie owl:disjointWith :JudiDenchMovie .

:JamesDeanMovie owl:disjointWith :AntonioBanderasMovie .

:JudyGarlandMovie owl:disjointWith :TomCuiseMovie .

:JudyGarlandMovie owl:disjointWith :JudyDenchMovie .

:JudyGarlandMovie owl:disjointWith :AntonioBanderasMovie .

:TomCruiseMovie owl:disjointWith :JudyDenchMovie .

:TomCruiseMovie owl:disjointWith :AntonioBanderasMovie .

:JudiDenchMovie owl:disjointWith :AntonioBanderasMovie .

Given

Paul has 3 James Dean movies and at least 1 movie with each of the other actors mentioned

None of these movies appears twice (all sets disjoint)

an inference engine can confirm

:Paul a :SevenMovieOwner .

Figure 6 shows these assertions and inferences

Note how owl:someValuesFrom interacts with cardinality

Each owl:someValueFrom restriction guarantees the existence of one value for the specified property

Given the values are distinct, can count at least 1 per owl:someValuesFrom restriction

Just as owl:AllDifferent lets us specify that several individuals are mutually distinct,

could have something like owl:AllDisjoint to specify that a set of classes are mutually disjoint

The OWL standard didn’t include such a construct

But some proposals for OWL extensions include it

Prerequisites Revisited We explored how prerequisites can be modeled using

owl:allValuesFrom

But had a problem with the Open World Assumption: How can we tell that all prerequisites have been satisfied?

Now show several ways to close the world

Recall that we modeled the fact that something has all its prerequisites selected is a q:EnabledQuestion as

q:hasPrerequisite a owl:ObjectProperty .


owl:onProperty q:hasPrerequisite;

owl:allValuesFrom q:SelectedAnswer]

rdfs:subClassOf q:EnableQuestion .

No Prerequisites To assert that an individual has no values for some property, use a

cardinality restriction

c:WhatProblem a [ a owl:Restriction;



So there are no triples of the following form, i.e., c:WhatProblem has no prerequisites

c:WhatProblem q:hasPrerequisite ?x .

So c:WhatProlem satisfies

c:WhatProblem a [ a owl:Restriction;


owl:allValuesFrom q:SelectedAnswer] .

Hence

c:WhatProblem a q:EnabledQuestion .

In summary, this holds since all of this problem’s prerequisites have been selected

Vacuously true since it has no prerequisites

Note: x A(x) B(x) is true if it’s true for every substitution instance x/a, where a denotes an individual

A(a) B(a) is true if A(a) is false

If A(a) is false for every individual a, then A(a) B(a) is true for every individual

I.e., x A(x) B(x) is true when nothing satisfies A(x)

Counting Prerequisites Also determine that something satisfies its prerequisites by counting how

many there are (as with the James Dean movies)

Suppose something has 1 prerequisite

d:TvSymptom a [ a owl:Restriction;

owl:onProperty hasPrerequisite;


And suppose we know 1 prerequisite and its type

d:TvSymptom q:hasPrerequisite d:STV .

d:STV a q:SelectedAnswer .

One prerequisite is a member of q:SelectedAnswer and there aren’t any other prerequisites

So all prerequisites are members of q:SelectedAnswer

d:TVSymptom a [ a owl:Restriction;



Can make inferences with larger counts (as with the James Dean movies) if all entities are different

Given

d:TVTurnedOn a [ a owl:Restriction;



d:TVTurnedOn q:hasPrerequisite d:TVSnothing .

d:TVTurnedOn q:hasPrerequisite d:STVSnosound .

d:TVSnothing owl:differentFrom d:STVSnosound .

d:TVSnothing a q:SelectedAnswer .

d:STVSnosound a q:SelectedAnswer .

infer (since only 2 prerequisites and we know which they are)

d:TVTurnedOn a [ a owl:Restriction;



Guarantees of Existence Recall: Membership of individual A in an owl:allValuesFrom restriction

on property P doesn’t guarantee existence of a triple of the form

A P ?x .

If A is a member of a restriction owl:onProperty P owl:someValuesFrom class C, can infer there’s a pair of triples

A P ?x .

?x rdf:type C .

So owl:someValuesFrom does guarantee the existence of some value for the given property

owl:hasValue not only guarantees such a triple but even specifies it

I.e., if A is a member of the restriction owl:onProperty P owl:hasValue X, can infer

A P X .

ContradictionsChallenge 33 Model the following situation and conclusion in OWL

Rocky: I have a couple of Judy Garland movies.

Rimbaud: But you said you own only James Dean movies, and he and Judy Garland weren’t in any movie together.

This introduces a new aspect of inferencing in OWL

In the simplest form of inferencing, we infer triples based on asserted ones

With notions more advanced than RDFS-Plus,

some inferences themselves can’t be represented as triples

but can result in new triples when combined with other assertions

But here no new triples are inferred at all

Rimbaud found a contradiction in what Rocky said

The contradiction arises because Rocky states the following

:JamesDeanExclusive owl:equivalentClass



owl:allValuesFrom :JamesDeanMovie] .

:Rocky a :JamesDeanExclusive .

:Rocky a [ a owl:Restriction;


owl:someValuesFrom :JudyGarlandMovie] .

:JudyGarlandMovie owl:disjointWith :JamesDeanMovie .

Figure 7 (next slide) shows the assertions (no inferences)

The OWL semantics can tell us that there’s a contradiction but not which assertion is wrong

The truth of an assertion relates, not to OWL semantics, but to the domain being modeled

A model may fail to correspond to the actual state of affairs

If this is because it’s logically inconsistent (so couldn’t correspond to any state of affairs), the tools surrounding OWL can tell us so

Unsatisfiable Classes A contradiction involves a set of assertions that can’t all be true at the

same time

A similar situation arises when we define a class in an inconsistent way

Illustrate this with a slight variation on the previous example

First define the class of people owning Judy Garland movies

:JudyGarlandMovieOwner owl:equivalentClass



owl:someValueFromm :JudyGarlandMovie] .

Now, instead of claiming that Rocky is a member of this class and JamesDeanExclusive, define a class of such people

:JDJG owl:intersectionOf

( :JudyGarlandMovieOwner :JamesDeanExclusive ) .

We can define this class without asserting that Rocky (or anything else) is a member, hence without involving a contradiction

But the same argument showing that Rocky can’t be a member shows that nothing can be a member of this class

Not only is the class empty, it must be empty—it (or the description of what it contains, which implicitly involves a variable) is unsatisfiable

Asserting that something is a member of an unsatisfiable class introducers a contradiction into the model

Figure 8 shows the assertions and conclusions

JDJG, being the intersection of JudyGarlandMovieOwner and JamesDeanExclusive, is a subclass of both

It’s inferred to be a subclass of owl:Nothing, the necessarily empty class

Propagation of Unsatisfiable Classes An unsatisfiable class easily leads to other unsatisfiable class

definitions

subclass If a class can’t have any members, then no subclass of it can have a

member (which would thereby be a member too of the class)

someValuesFrom

A restriction with owl:someValuesFrom an unsatisfiable class is itself unsatisfiable

domain and range If a property has an unsatisfiable domain or range, it’s unusable

Asserting any triple using the property as predicate results in a contradiction

intersection of disjoints The intersection of 2 disjoint classes is unsatisfiable

The intersection of any class with an unsatisfiable class is unsatisfiable

Some operations don’t propagate unsatisfiability

The union of class C with an unsatisfiable class is just C

A restriction owl:allValuesFrom an unsatisfiable class can be satisfiable—

vacuously so: no member can have the property in question

The usefulness of these rules in modeling comes during analysis of the results of an inference engine

Many inference engines report on unsatisfiable classes

But, with several such classes, it’s hard to unravel the threads

Inferring Class Relationships Earlier focused on drawing inferences about individuals but have

shifted to inferences about classes

Some of the more common of the many patterns are the following

Use set notation for brevity (and clarity)

Intersections and subclass A B A, A B B

Union and subclass A B A, A B B

Complement and subclass If A B then A B

Subclass propagation through restriction owl:allValuesFrom

If A B then { x | y P(x,y) y A } { x | y P(x,y) y B }

owl:someValuesFrom

If A B then { x | y P(x,y) y A } { x | y P(x,y) y B }

hasValue, someValuesFrom, and subClassOf If a A then { x | P(x,a) } { x | y P(x,y) y A }

Relative cardinalities For natural number c, d where d > c,

{ x | card({ y | P(x,y ) } ) = d } { x | card({ y | P(x,y ) } ) c }

Examples Subclass propagation through restriction If :AllStarBaseballTeam is a subclass of :BaseballTeam,

then the restriction (on any property, e.g., :playsFor)

owl:allValuesFrom :AllStarBaseballTeam

is a subclass of the restriction (on the same property :playsFor)

owl:allValuesFrom :BaseballTeam

hasValue, someValuesFrom, and subClassOf Suppose individual :TokyoGiants is a member of class :BaseballTeam

The restriction on property :playsFor

owl:hasValue :TokyoGiants

is a subclass of the restriction on :playsFor

owl:someValuesFrom :BaseballTeam

Relative cardinalities Suppose a :ViableBaseballTeam must have at least 9 players on its

roster and a :FullBaseballTeam has exactly 10 players

:FullBaseballTeam is a subclass of :ViableBaseBallTeam

owl:someValuesFrom and owl:minCardinality Suppose :BaseballTeam has some pitcher, i.e., :BaseballTeam is a

subclass of the restriction

owl:onProperty :hasPlayer owl:someValuesFrom :Pitcher

Can infer that it has at least 1 pitcher, i.e., :BaseballTeam is a subclass of the restriction

owl:onProperty :hasPlayer owl:minCardinality 1

Any class relationship that can be proven based on the semantics of the OWL constructs will be inferred by the logic underlying OWL

We’ve seen only the more common propagation patterns

Inferring class relationships in OWL is in sharp contrast to OO modeling

In OO modeling, all instances are created as members of some class Their behavior is specified by the class structure

In OWL, the class structure can change as more info is learned about classes and individuals

These aspects of OWL are direct consequences of the basic assumptions about the web

AAA slogan, Open World assumption, Nonunique Naming assumption

A strict data model (e.g., an OO model) is useful when there’s top-down governance of the system

Doesn’t work in an open, free system

Our understanding of the structure of knowledge changes as we discover new things

OWL provides a consistent and systematic way to understand those changes

OWL’s ability to infer class relationships enables a style of modeling where subclass relationships are rarely asserted directly

Instead, relationships between classes are described in terms of unions, intersections, complements, restrictions

And the inference engine determines the class structure

If more info is learned about a given class or individual, more class structure can be inferred

Illustrate this principle with the baseball model—Table 1

Here indicates class equivalence, indicates subclass

Figure 9 shows the class tree asserted

Some subclass relationships inferred from the definitions in Table 1 and our subclass inferencing patterns

AllStarBaseballTeam BaseballTeam AllStarTeam, so AllStarBaseballTeam BaseballTeam

AllStarBaseballTeam AllStarTeam

Both AllStarBaseballPlayer and AllStarPlayer are someValuesFrom restrictions on property playsFor, referencing, resp.,

AllStarBaseballTeam

AllStarTeam

Propagate AllStarBaseballTeam AllStarTeam to infer

AllStarBaseballPlayer AllStarPlayer

Similar reasoning lets us infer

AllStarBaseballPlayer BaseballPlayer

JBallTeam PacificLeagueTeam CentralLeagueTeam, so

PacificLeagueTeam JBallTeam

PacificLeagueTeam JBallTeam

Hiroshima Carp is a Central League Team so also a JBallTeam and, further, a BaseballTeam

A CarpPlayer is a hasValue restriction on the Carp, so

CarpPlayer BaseballPlayer

AllStarPlayer is equivalent to the someValuesFrom restriction onProperty playsFor

So any individual member of AllStarPlayer playsFor some team But domain(playsFor) Player So that individual is also a Player

Just shown AllStarPlayer Player

AllStarTeam employs some AllStarPlayer and employs is the inverse of playsFor

So some person playsFor any AllStarTeam But range(playsFor) is Team

So AllStarTeam Team

Figure 10 shows the inferred class structure

Every class is involved in some class inferencing pattern

So the inferred structure (unlike the asserted one) has considerable depth

Reasoning with Individuals and Classes From an RDF perspective, inferencing about individuals and

inferencing about classes are very similar

New triples are added to the model based on asserted triples

From a modeling perspective, the 2 kinds of reasoning are very different

One draws specific conclusions about individuals in a data stream (A-box reasoning)

The other draws general conclusions about classes of individuals (T-box reasoning)

The utility of reasoning about individuals in a Semantic Web context is clear

Info specified in one source is transformed according to a model for use in another context

Mappings from one context to the next are specified with such constructs as rdfs:subClassOf, rdfs:subPropertyOf, and various owl:Restrictions

Data are then transformed and processed according to

these models and

the inferences specified in the RDFS and OWL standards for each

The utility of reasoning about classes is more subtle

Determines how data are related in general, even before any data is present

Records relationships with rdfs:subClassOf, rdfs:subPropertyOf, rdfs:domain, rdfs:range

Once these general relationships are inferred, processing individual data is much easier

Documents

Counting and Sets in OWL OWL augments restrictions with a full set-theoretic language, including intersections, unions, complements Using these, we combine