FR Implementation

{toc}
{color:red}*Do not edit this page in Rich Text mode, edit only in Wiki mode*{color}

RS3.1 FRs were implemented using reasoning dialect "OWL RL (optimized)", i.e. builtin_owl2-rl.pie.
We used constructs owl:PropertyChainAxiom, owl:TransitiveProperty, owl:ReflexiveProperty, and rdfs:subPropertyOf (which amounts to disjunction).
But as described in [OWLIM Rules vs OWL RL#Less Expressive], OWL RL is less expressive than OWLIM Rules, since one cannot define a property by conjunction.
We are pretty sure the full FR set will require conjunction, so we'll go with OWLIM Rules. See [OWLIM Rules documentation|http://owlim.ontotext.com/display/OWLIMv43/OWLIM-SE+Reasoner#OWLIM-SEReasoner-RuleFormatandSemantics].

We'll use the RDFS reasoning dialect as a basis, by weaving our rules into builtin_RdfsRules.pie. That file is part of the OWLIM distribution, in my case
c:\my\Onto\proj\OWLIM\software\owlim-se-4.2.3924\builtin_RdfsRules.pie

h2. Weaving for Production
This page is used to generate OWLIM artefacts for production. We "weave" them from \{code} blocks in the page, following [Literate Programming|http://en.wikipedia.org/wiki/Literate_Programming]. We weave several files based on code block titles:
||Title ||Weaved into||
|Turtle | (x) (not yet implemented) FR.ttl, The old file RF.ttl will be deleted from svn|
|Prefices| builtin_RdfsRules.pie, at the beginning of section Prefices (after the opening brace)|
|Axioms | builtin_RdfsRules.pie, at the beginning of section Axioms (after the opening brace)|
|Rule | builtin_RdfsRules.pie, at end of file (before the closing brace)|
|Rules | same place, but these are shorthand rules (see below)|
- the weaver automatically generates rule identifiers in the form "Id: fr$n" where $n is a counter
- "Rule" includes one rule per code block in the OWLIM notation, eg:
{code}
premise1 [Constraint ...]
premise2 [Cut]
-------------------
corollary1
corollary2
{code}
- "Rules" includes one rule per line in a shorthand notation, eg:
{code}
premise1 [Constraint ...]; premise2 [Cut] => corollary1; corollary2
{code}
The shortcut notation is translated to the OWLIM notation. This shortcut form is very useful for shorter rules

h2. Modularity and Naming
A very important aspect of our implementation is modularity: we define appropriate sub-FRs and use them when defining FRs.
We use the Erlangen CRM (ECRM) naming variant (underscores instead of dots), and the following naming conventions:
- crm: Enn_entity_name, crm: Pnn_property_name: CRM entities and properties
- rso:FRnn_name: property representing an FR
-- rso stands for "RS ontology"
-- nn is a number that we try to keep the same as a related CRM property number (eg FR7_thing_from_place is numbered after P7_took_place_at)
- rso:FRXnn_name: property representing a sub-FR
-- if the sub-FR is a disjunction of several CRM properties, we mention all numbers
FRX_62_67 := P62_depicts or P67_refers_to
- rso:FRTnn_name: transitive closure of crm: Pnn_name
-- we denote this as FRTnn_name := Pnn_name+
- rso:FRSTnn_name: symmetric-transitive closure of crm: Pnn_name
-- we denote this as FRSTnn_name := (Pnn_name or Pnni_inverse_name)+
- rso:FCnn_name: Fundamental Concept or another class used in defining FRs

h2. Prefixes
This adds prefixes to FR.ttl:
{code:title=Turtle}
@prefix crm : <http://erlangen-crm.org/current/> .
@prefix owl : <http://www.w3.org/2002/07/owl#> .
@prefix rdf : <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs : <http://www.w3.org/2000/01/rdf-schema#> .
@prefix rso : <http://www.researchspace.org/ontology/> .
{code}

This adds prefixes to the rules file (it already has: rdf rdfs owl xsd):
{code:title=Prefices}
crm : http://erlangen-crm.org/current/
rso : http://www.researchspace.org/ontology/
{code}

h2. Transitive Properties
ECRM declares appropriate CRM properties as owl:TransitiveProperty.
For some reason it doesn't declare P9,P46 transitive, though it does it for other "part of" properties, eg P106,P148. I posted a bug to CRM SIG and fix it here:
{code:title=Axioms}
<crm:P9_consists_of> <rdf:type> <owl:TransitiveProperty>
<crm:P9i_forms_part_of> <rdf:type> <owl:TransitiveProperty>
<crm:P46_is_composed_of> <rdf:type> <owl:TransitiveProperty>
<crm:P46i_forms_part_of> <rdf:type> <owl:TransitiveProperty>
{code}

The full list of transitive properties is:
- P9_consists_of, P9i_forms_part_of (ADDED)
- P10_falls_within, P10i_contains
- P46_is_composed_of, P46i_forms_part_of (ADDED)
- P86_falls_within, P86i_contains
- P88_consists_of, P88i_forms_part_of
- P89_falls_within, P89i_contains
- P106_is_composed_of, P106i_forms_part_of
- P114_is_equal_in_time_to
- P115_finishes, P115i_is_finished_by
- P116_starts, P116i_is_started_by
- P117_occurs_during, P117i_includes
- P120_occurs_before, P120i_occurs_after
- P127_has_broader_term, P127i_has_narrower_term
- P148_has_component, P148i_is_component_of

h2. Inverse Properties
Most CRM properties have an inverse, eg P110i_was_augmented_by is inverse of P110_augmented (Symmetric properties are their own inverse). ECRM declares all inverse properties as owl:inverseOf.

We use the RDFS reasoning dialect as a basis, which implements rdfs:subClassOf and rdfs:subPropertyOf reasoning.
But it's very useful in FR definitions to rely on general Transitive and Inverse reasoning, which frees you from dependencies on how exactly data is asserted.

{code}

h2. Symmetric Properties
ECRM declares all CRM symmetric properties as owl:SymmetricProperty. ECRM always declares them as owl:inverseOf itself, so we don't need to treat them separately. Eg:
{code}
crm:P122_borders_with rdf:type owl:SymmetricProperty.
crm:P122_borders_with owl:inverseOf crm:P122_borders_with.
{code}

The full list of symmetric properties is:
- P69_is_associated_with
- P114_is_equal_in_time_to
- P121_overlaps_with
- P122_borders_with
- P132_overlaps_with
- P133_is_separated_from

h2. No Reflexive Closure
FR definitions are full of reflexive-transitive sub-FRs. In FRThing.docx they are denoted (Pnnn)(0,n), and below we denote them as Pnn*. Eg
- x from z := x P74 y AND y P89* z

But I think it's bad style to use reflexive closure in the implementation since it generates lots of trivial facts (self-loops) in the semantic repository. Instead of reflexive closure, we use disjunction: the iterated property is applied 0 times in the first disjunct, and n times in the second, eg:
- x from z := x P74 z OR (x P74 y AND y P89+ z)

h2. FR Notes
FR design in the following sections is based on FRThing.docx by M.Doerr and K.Tzompanaki, after clarifications and corrections by V.Alexiev.
- We don't implement FRs:
-- for which there is no data in neither Rembrandt nor BM collections
-- that are interesting for history/archaeology but not museum collections (eg Destroyed at)
-- that use the CRM Digital (CRMdig) extensions
- We omit composite FR such as "Was created/produced by person from" since they are treated separately
- In many cases we don't check types, since these are implied by the domain/range of a property. Eg in:
-- E24.Physical_Man-Made_Thing -- P128F.carries -> E73.Information_Object
the property P128 implies that the source and target have the indicated types

h1. Fundamental Concepts

h2. Thing

h3. FC70_Thing in General
"Thing" is defined as the following (was called C1.Object):

#- Resolved: we mix all these properties freely: any path of the indicated properties, in any order, of any length
# At E73: does not allow P106_is_composed_of, P148_has_component which are legitimate for E73 (being a subclass of both E89_Propositional_Object and E90_Symbolic_Object)
#- Resolved: we add P128 into the mix.
Did we mix it up too much? I think it's ok: not all allowed paths are correct, but all correct and relevant paths are allowed
# At E26: does not allow P130,P130i,P46

x <crm:P62_depicts> y => x <rso:FRX_62_67> y
x <crm:P67_refers_to> y => x <rso:FRX_62_67> y
{code}

- FRX_62_67_E26 := FRX_62_67 and check type E26
{code:title=Rules}
x <rso:FRX_62_67> y; y <rdf:type> <crm:E26_Physical_Feature> => x <rso:FRX_62_67_E26> y
{code}

- FRX67_refers_to_or_is_about := paths from FC70 to E53, with no loops nor type check at start & end
{code:title=Rules}

- FRT67_refers_to_or_is_about := add loops at start & end
(Note: ECRM defines P89i_contains as transitive)

- FR67_refers_to_or_is_about := add type check at start & end
{code:title=Rules}
x <rdf:type> <rso:FC70_Thing>; x <rso:FRT67_refers_to_or_is_about> y; y <rdf:type> <crm:E53_Place> => x <rso:FR67_refers_to_or_is_about> y

# At E9: does not allow a loop P9i* (Move forms part of a bigger event)
#- Resolved by merging all Event nodes (E8, E9, second E63) and allowing P9i*
#- Note that P26,P27 are subproperties of P7, so we don't need to use them

x <crm:P46i_forms_part_of> y => x <rso:FRT_46i_106i_148i> y
x <crm:P106i_forms_part_of> y => x <rso:FRT_46i_106i_148i> y
x <crm:P148i_is_component_of> y => x <rso:FRT_46i_106i_148i> y
{code}
{code:title=Axioms}
<rso:FRT_46i_106i_148i> <rdf:type> <owl:TransitiveProperty>
{code}

- FRX_53_54_current_location := P53 or P54
{code:title=Rules}
x <crm:P53_has_former_or_current_location> y => x <rso:FRX_53_54_current_location> y
x <crm:P54_has_current_permanent_location> y => x <rso:FRX_53_54_current_location> y

x <crm:P92i_was_brought_into_existence_by> y; y <crm:P9i_forms_part_of> z => x <rso:FRT92i_9i> z
{code}

- FRT107i_member_of := P107i+
{code:title=Rules}
x <crm:P107i_is_current_or_former_member_of> y => x <rso:FRT107i_member_of> y
{code}
{code:title=Axioms}
<rso:FRT107i_member_of> <rdf:type> <owl:TransitiveProperty>
{code}

- FRX_P92i_P14_P107i := FRT92i_9i then P14 then P107i*
{code:title=Rules}
x <rso:FRT92i_9i> y; y <crm:P14_carried_out_by> z => x <rso:FRX_P92i_P14_P107i> z
x <rso:FRT92i_9i> y; y <crm:P14_carried_out_by> z; z <rso:FRT107i_member_of> t => x <rso:FRX_P92i_P14_P107i> t
{code}

- FRX_FC70_key_event := paths from FC70 to E8,E9,E63 (a "key event")
{code:title=Rules}
x <crm:P24i_changed_ownership_through> y => x <rso:FRX_FC70_key_event> y
x <crm:P25i_moved_by> y => x <rso:FRX_FC70_key_event> y
x <rso:FRX_P92i_P14_P107i> y; y <crm:P92i_was_brought_into_existence_by> z => x <rso:FRX_FC70_key_event> z
{code}

- FRT_FC70_key_event_P9i := FRX_FC70_key_event then P9i*
{code:title=Rules}
x <rso:FRX_FC70_key_event> y => x <rso:FRT_FC70_key_event_P9i> y
x <rso:FRX_FC70_key_event> y; y <crm:P9i_forms_part_of> z => x <rso:FRT_FC70_key_event_P9i> z
{code}

- FRX7_from_place := paths from FC70 to E53, with no loops nor type check at start & end
{code:title=Rules}
x <rso:FRX_53_54_current_location> y => x <rso:FRX7_from_place> y
x <rso:FRT_FC70_key_event_P9i> y; y <crm:P7_took_place_at> z => x <rso:FRX7_from_place> z
x <rso:FRX_P92i_P14_P107i> y; y <crm:P74_has_current_or_former_residence> z => x <rso:FRX7_from_place> z
x <rso:FRT92i_9i> y; y <crm:P7_took_place_at> z => x <rso:FRX7_from_place> z
{code}

- FRT7_from_place := add loops at start & end
{code:title=Rules}
x <rso:FRX7_from_place> y => x <rso:FRT7_from_place> y
x <rso:FRT_46i_106i_148i> y; y <rso:FRX7_from_place> z => x <rso:FRT7_from_place> z
x <rso:FRX7_from_place> y; y <crm:P89_falls_within> z => x <rso:FRT7_from_place> z
{code}

- FR7_from_place := add type check at start
(No need to check at end since all relations are to E53_Place)
{code:title=Rules}
x <rdf:type> <rso:FC70_Thing>; x <rso:FRT7_from_place> y => x <rso:FR7_from_place> y