diff --git a/owl/DUL.owl b/owl/DUL.owl index 525bbbc4..3e33a8e8 100644 --- a/owl/DUL.owl +++ b/owl/DUL.owl @@ -555,7 +555,7 @@ SymmetricObjectProperty( ) ObjectPropertyRange( ) -# Object Property: (ha componente) +# Object Property: (has component) AnnotationAssertion(rdfs:comment "The hasProperPart relation without transitivity, holding between an Object (the system) and another (the component), and assuming a Design that structures the Object.") AnnotationAssertion(rdfs:isDefinedBy ) @@ -1394,7 +1394,7 @@ SubObjectPropertyOf( ) ObjectPropertyRange( ) -# Object Property: (realizes self information) +# Object Property: (realizes self-information) AnnotationAssertion(rdfs:comment "This relation is a workaround to enable local reflexivity axioms (Self) working with non-simple properties; in this case, dul:realizesInformation About.") AnnotationAssertion(rdfs:isDefinedBy ) diff --git a/owl/SOMA-ACT.owl b/owl/SOMA-ACT.owl old mode 100755 new mode 100644 index 049be4e8..47faa2f9 --- a/owl/SOMA-ACT.owl +++ b/owl/SOMA-ACT.owl @@ -19,25 +19,26 @@ This module is chiefly concerned with defining a taxonomy of tasks, including ro Also defined here are execution state regions, i.e. flags with which to label the status of the execution of an action in terms of whether it is unfolding or completed, and if completed whether completed successfully or not.") -Declaration(Class(:AnsweringTask)) Declaration(Class(:Cleaning)) Declaration(Class(:Flipping)) Declaration(Class(:Pouring)) Declaration(Class(:PouringInto)) Declaration(Class(:PouringOnto)) -Declaration(Class(:QueryAnsweringTask)) Declaration(Class(:Serving)) Declaration(Class(:Stirring)) Declaration(Class(SOMA:AbductiveReasoning)) Declaration(Class(SOMA:Actuating)) Declaration(Class(SOMA:Answer)) +Declaration(Class(SOMA:AnsweringTask)) Declaration(Class(SOMA:AreaSurveying)) Declaration(Class(SOMA:Arranging)) Declaration(Class(SOMA:Assembling)) Declaration(Class(SOMA:AssertionTask)) Declaration(Class(SOMA:AssumingArmPose)) Declaration(Class(SOMA:AssumingPose)) +Declaration(Class(SOMA:AttentionShift)) Declaration(Class(SOMA:Avoiding)) +Declaration(Class(SOMA:Capability)) Declaration(Class(SOMA:Catching)) Declaration(Class(SOMA:Channel)) Declaration(Class(SOMA:CheckingObjectPresence)) @@ -47,18 +48,24 @@ Declaration(Class(SOMA:CommunicationAction)) Declaration(Class(SOMA:CommunicationReport)) Declaration(Class(SOMA:CommunicationTask)) Declaration(Class(SOMA:CommunicationTopic)) +Declaration(Class(SOMA:Conclusion)) Declaration(Class(SOMA:Constructing)) Declaration(Class(SOMA:Cutting)) +Declaration(Class(SOMA:Deciding)) Declaration(Class(SOMA:DeductiveReasoning)) Declaration(Class(SOMA:Delivering)) +Declaration(Class(SOMA:DerivingInformation)) Declaration(Class(SOMA:Dicing)) -Declaration(Class(SOMA:Dish)) +Declaration(Class(SOMA:Discourse)) Declaration(Class(SOMA:Distancing)) Declaration(Class(SOMA:Dreaming)) Declaration(Class(SOMA:Dropping)) Declaration(Class(SOMA:EndEffectorPositioning)) Declaration(Class(SOMA:ExecutionStateRegion)) Declaration(Class(SOMA:Fetching)) +Declaration(Class(SOMA:Focusing)) +Declaration(Class(SOMA:ForgettingIncorrectInformation)) +Declaration(Class(SOMA:ForgettingIrrelevantInformation)) Declaration(Class(SOMA:GetTaskParameter)) Declaration(Class(SOMA:GraspTransfer)) Declaration(Class(SOMA:Grasping)) @@ -66,12 +73,24 @@ Declaration(Class(SOMA:Holding)) Declaration(Class(SOMA:IllocutionaryTask)) Declaration(Class(SOMA:Imagining)) Declaration(Class(SOMA:InductiveReasoning)) +Declaration(Class(SOMA:InferenceRules)) +Declaration(Class(SOMA:InformationAcquisition)) +Declaration(Class(SOMA:InformationDismissal)) +Declaration(Class(SOMA:InformationRetrieval)) +Declaration(Class(SOMA:InformationStorage)) +Declaration(Class(SOMA:Instructions)) +Declaration(Class(SOMA:Interpreting)) +Declaration(Class(SOMA:Introspecting)) +Declaration(Class(SOMA:Knowledge)) +Declaration(Class(SOMA:Labeling)) +Declaration(Class(SOMA:Learning)) Declaration(Class(SOMA:Lifting)) Declaration(Class(SOMA:LinguisticObject)) Declaration(Class(SOMA:LookingAt)) Declaration(Class(SOMA:LookingFor)) Declaration(Class(SOMA:Lowering)) Declaration(Class(SOMA:Manipulating)) +Declaration(Class(SOMA:Memorizing)) Declaration(Class(SOMA:MentalAction)) Declaration(Class(SOMA:MentalTask)) Declaration(Class(SOMA:Message)) @@ -79,6 +98,8 @@ Declaration(Class(SOMA:MetaCognitionEvaluationTopic)) Declaration(Class(SOMA:MetaCognitionMemoryTopic)) Declaration(Class(SOMA:MetaCognitionPlanningTopic)) Declaration(Class(SOMA:MetaCognitionTopic)) +Declaration(Class(SOMA:MetacognitiveControlling)) +Declaration(Class(SOMA:MetacognitiveMonitoring)) Declaration(Class(SOMA:Mixing)) Declaration(Class(SOMA:ModifyingPhysicalObject)) Declaration(Class(SOMA:MonitoringJointState)) @@ -96,6 +117,7 @@ Declaration(Class(SOMA:Placing)) Declaration(Class(SOMA:Planning)) Declaration(Class(SOMA:Positioning)) Declaration(Class(SOMA:Prediction)) +Declaration(Class(SOMA:Premise)) Declaration(Class(SOMA:Proprioceiving)) Declaration(Class(SOMA:Prospecting)) Declaration(Class(SOMA:Pulling)) @@ -104,15 +126,18 @@ Declaration(Class(SOMA:PushingAway)) Declaration(Class(SOMA:PushingDown)) Declaration(Class(SOMA:PuttingDown)) Declaration(Class(SOMA:Query)) +Declaration(Class(SOMA:QueryAnsweringTask)) Declaration(Class(SOMA:QueryingTask)) Declaration(Class(SOMA:Reaching)) Declaration(Class(SOMA:Reasoning)) Declaration(Class(SOMA:Receiver)) Declaration(Class(SOMA:Releasing)) Declaration(Class(SOMA:Remembering)) +Declaration(Class(SOMA:Replanning)) Declaration(Class(SOMA:Retracting)) Declaration(Class(SOMA:Retrospecting)) Declaration(Class(SOMA:SelectingItem)) +Declaration(Class(SOMA:SelfReflection)) Declaration(Class(SOMA:Sender)) Declaration(Class(SOMA:SettingGripper)) Declaration(Class(SOMA:Simulating)) @@ -132,21 +157,29 @@ Declaration(Class(SOMA:ThinkAloudTopic)) Declaration(Class(SOMA:Throwing)) Declaration(Class(SOMA:Transporting)) Declaration(Class()) -Declaration(ObjectProperty(:causes)) -Declaration(ObjectProperty(:directlyCauses)) -Declaration(ObjectProperty(:isDirectReactionTo)) -Declaration(ObjectProperty(:isReactionTo)) Declaration(ObjectProperty(SOMA:answers)) +Declaration(ObjectProperty(SOMA:causes)) +Declaration(ObjectProperty(SOMA:definesEventType)) +Declaration(ObjectProperty(SOMA:directlyCauses)) Declaration(ObjectProperty(SOMA:hasAction)) Declaration(ObjectProperty(SOMA:hasAnswer)) Declaration(ObjectProperty(SOMA:hasExecutionState)) Declaration(ObjectProperty(SOMA:hasInitialSituation)) Declaration(ObjectProperty(SOMA:hasTerminalSituation)) Declaration(ObjectProperty(SOMA:isAskedBy)) +Declaration(ObjectProperty(SOMA:isCreatedOutputOf)) +Declaration(ObjectProperty(SOMA:isDirectReactionTo)) +Declaration(ObjectProperty(SOMA:isEventTypeDefinedIn)) Declaration(ObjectProperty(SOMA:isInitialSituationOf)) Declaration(ObjectProperty(SOMA:isPerformedBy)) +Declaration(ObjectProperty(SOMA:isReactionTo)) +Declaration(ObjectProperty(SOMA:isReplacedBy)) +Declaration(ObjectProperty(SOMA:isTaskOfCreatedRole)) Declaration(ObjectProperty(SOMA:isTerminalSituationOf)) +Declaration(ObjectProperty(SOMA:isTerminatedBy)) Declaration(ObjectProperty(SOMA:relatesToAnotherRole)) +Declaration(ObjectProperty(SOMA:replaces)) +Declaration(ObjectProperty(SOMA:terminates)) Declaration(ObjectProperty()) Declaration(ObjectProperty()) Declaration(ObjectProperty()) @@ -163,54 +196,45 @@ Declaration(NamedIndividual(SOMA:ExecutionState_Succeeded)) # Object Properties ############################ -# Object Property: :causes (causes) - -AnnotationAssertion(rdfs:label :causes "Simple relationship between two actions to express that the object (the reaction) would not have occured if it were not for the subject (the cause), e.g., a Communication Action classified as an Querying Task causes another Communication Task classified as an Answering Task and the latter would not have occured without the former. An example without Agents involved would be some domino stone would not have toppled without the first one toppling. - -When Agents are involved, the relation might be seen as an abstraction of the execution of some plan that arises from changing the agents goal that is due to perceiving the cause. However, currently it is unclear how to model such a pattern and therefore not included in SOMA. +# Object Property: SOMA:answers (answers) -This relation is seen as transitive."@en) -AnnotationAssertion(rdfs:label :causes "causes"@en) -SubObjectPropertyOf(:causes ) -TransitiveObjectProperty(:causes) +AnnotationAssertion(rdfs:label SOMA:answers "The relation between an answering message and the message it answers.") +AnnotationAssertion(rdfs:label SOMA:answers "answers") +SubObjectPropertyOf(SOMA:answers SOMA:relatesToAnotherRole) +InverseObjectProperties(SOMA:answers SOMA:hasAnswer) +ObjectPropertyDomain(SOMA:answers SOMA:Message) +ObjectPropertyRange(SOMA:answers SOMA:Message) -# Object Property: :directlyCauses (directly causes) +# Object Property: SOMA:causes (causes) -AnnotationAssertion(rdfs:comment :directlyCauses "Non-transitive version of \"causes\"."@en) -AnnotationAssertion(rdfs:label :directlyCauses "directly causes"@en) -SubObjectPropertyOf(:directlyCauses :causes) -InverseObjectProperties(:directlyCauses :isDirectReactionTo) -ObjectPropertyDomain(:directlyCauses ) -ObjectPropertyRange(:directlyCauses ) +AnnotationAssertion(rdfs:label SOMA:causes "Simple relationship between two actions to express that the object (the reaction) would not have occured if it were not for the subject (the cause), e.g., a Communication Action classified as an Querying Task causes another Communication Task classified as an Answering Task and the latter would not have occured without the former. An example without Agents involved would be some domino stone would not have toppled without the first one toppling. -# Object Property: :isDirectReactionTo (is direct reaction to) +When Agents are involved, the relation might be seen as an abstraction of the execution of some plan that arises from changing the agents goal that is due to perceiving the cause. However, currently it is unclear how to model such a pattern and therefore not included in SOMA. -AnnotationAssertion(rdfs:comment :isDirectReactionTo "Non-transitive version of \"is reaction to\"."@en) -AnnotationAssertion(rdfs:label :isDirectReactionTo "is direct reaction to"@en) -SubObjectPropertyOf(:isDirectReactionTo :isReactionTo) -ObjectPropertyDomain(:isDirectReactionTo ) -ObjectPropertyRange(:isDirectReactionTo ) +This relation is seen as transitive."@en) +AnnotationAssertion(rdfs:label SOMA:causes "causes"@en) +SubObjectPropertyOf(SOMA:causes ) +TransitiveObjectProperty(SOMA:causes) -# Object Property: :isReactionTo (is reaction to) +# Object Property: SOMA:definesEventType (defines event type) -AnnotationAssertion(rdfs:comment :isReactionTo "Simple relationship between two actions to express that the subject (the reaction) would not have occured if it were not for the object (the cause), e.g., a Communication Action classified as an Answering Task is a reaction to another Communication Task classified as a Query Task and would not have occured without the other. An example without Agents involved would be some domino stone would not have toppled without the first one toppling. +AnnotationAssertion(rdfs:label SOMA:definesEventType "A relation between a description and an event type, e.g. an Affordance of an object to be cut with a knife describes that event. -When Agents are involved, the relation might be seen as an abstraction of the execution of some plan that arises from changing the agents goal that is due to perceiving the cause. However, currently it is unclear how to model such a pattern and therefore not included in SOMA. +The distinction to defines task is necessary to let Dispositions and Affordances not only describe which tasks might be afforded by objects, but also whihc processes (where there is no agent). For example, the fall of a knife from a shelf slicing a loaf of bread on impact is , in the absence of an executing agent, not a task but merely a process, the possibility of which is nevertheless described by the dispositions of the knife and the loaf."@en) +AnnotationAssertion(rdfs:label SOMA:definesEventType "defines event type"@en) +SubObjectPropertyOf(SOMA:definesEventType ) +InverseObjectProperties(SOMA:definesEventType SOMA:isEventTypeDefinedIn) +ObjectPropertyDomain(SOMA:definesEventType ) +ObjectPropertyRange(SOMA:definesEventType ) -This relation is seen as transitive."@en) -AnnotationAssertion(rdfs:label :isReactionTo "is reaction to") -SubObjectPropertyOf(:isReactionTo ) -TransitiveObjectProperty(:isReactionTo) -ObjectPropertyDomain(:isReactionTo ) -ObjectPropertyRange(:isReactionTo ) +# Object Property: SOMA:directlyCauses (directly causes) -# Object Property: SOMA:answers (answers) - -AnnotationAssertion(rdfs:label SOMA:answers "The relation between an answering message and the message it answers.") -AnnotationAssertion(rdfs:label SOMA:answers "answers") -SubObjectPropertyOf(SOMA:answers SOMA:relatesToAnotherRole) -ObjectPropertyDomain(SOMA:answers SOMA:Message) -ObjectPropertyRange(SOMA:answers SOMA:Message) +AnnotationAssertion(rdfs:comment SOMA:directlyCauses "Non-transitive version of \"causes\"."@en) +AnnotationAssertion(rdfs:label SOMA:directlyCauses "directly causes"@en) +SubObjectPropertyOf(SOMA:directlyCauses SOMA:causes) +InverseObjectProperties(SOMA:directlyCauses SOMA:isDirectReactionTo) +ObjectPropertyDomain(SOMA:directlyCauses ) +ObjectPropertyRange(SOMA:directlyCauses ) # Object Property: SOMA:hasAction (has action) @@ -225,6 +249,8 @@ ObjectPropertyRange(SOMA:hasAction ) ObjectPropertyRange(SOMA:hasExecutionState SOMA:ExecutionStateRegion) -# Object Property: SOMA:hasInitialSituation (SOMA:hasInitialSituation) +# Object Property: SOMA:hasInitialSituation (has initial situation) AnnotationAssertion(rdfs:comment SOMA:hasInitialSituation "A relation between SituationTransitions and Situations, which identifies the Situation the transition starts from.") -SubObjectPropertyOf(SOMA:hasInitialSituation ) +AnnotationAssertion(rdfs:label SOMA:hasInitialSituation "has initial situation"@en) +SubObjectPropertyOf(SOMA:hasInitialSituation SOMA:hasInitialState) InverseObjectProperties(SOMA:hasInitialSituation SOMA:isInitialSituationOf) AsymmetricObjectProperty(SOMA:hasInitialSituation) IrreflexiveObjectProperty(SOMA:hasInitialSituation) ObjectPropertyDomain(SOMA:hasInitialSituation SOMA:SituationTransition) ObjectPropertyRange(SOMA:hasInitialSituation ) -# Object Property: SOMA:hasTerminalSituation (SOMA:hasTerminalSituation) +# Object Property: SOMA:hasTerminalSituation (has terminal situation) AnnotationAssertion(rdfs:comment SOMA:hasTerminalSituation "A relation between SituationTransitions and Situations, which identifies the Situation the transition ends at.") -SubObjectPropertyOf(SOMA:hasTerminalSituation ) +AnnotationAssertion(rdfs:label SOMA:hasTerminalSituation "has terminal situation"@en) +SubObjectPropertyOf(SOMA:hasTerminalSituation SOMA:hasTerminalState) InverseObjectProperties(SOMA:hasTerminalSituation SOMA:isTerminalSituationOf) AsymmetricObjectProperty(SOMA:hasTerminalSituation) IrreflexiveObjectProperty(SOMA:hasTerminalSituation) @@ -256,17 +284,44 @@ ObjectPropertyRange(SOMA:hasTerminalSituation ) ObjectPropertyDomain(SOMA:isAskedBy SOMA:QueryingTask) ObjectPropertyRange(SOMA:isAskedBy ) +# Object Property: SOMA:isCreatedOutputOf (is created output of) + +AnnotationAssertion(rdfs:comment SOMA:isCreatedOutputOf "A relation between a created output role and its Task. The difference to isOutputRoleOf is that the latter is also applicable, e.g., for Deciding between objects, where the selected object is not created, but still an outcome of that task.") +AnnotationAssertion(rdfs:label SOMA:isCreatedOutputOf "is created output of") +SubObjectPropertyOf(SOMA:isCreatedOutputOf SOMA:isOutputRoleOf) +InverseObjectProperties(SOMA:isCreatedOutputOf SOMA:isTaskOfCreatedRole) +ObjectPropertyDomain(SOMA:isCreatedOutputOf ) +ObjectPropertyRange(SOMA:isCreatedOutputOf ) + +# Object Property: SOMA:isDirectReactionTo (is direct reaction to) + +AnnotationAssertion(rdfs:comment SOMA:isDirectReactionTo "Non-transitive version of \"is reaction to\"."@en) +AnnotationAssertion(rdfs:label SOMA:isDirectReactionTo "is direct reaction to"@en) +SubObjectPropertyOf(SOMA:isDirectReactionTo SOMA:isReactionTo) +ObjectPropertyDomain(SOMA:isDirectReactionTo ) +ObjectPropertyRange(SOMA:isDirectReactionTo ) + +# Object Property: SOMA:isEventTypeDefinedIn (is event type defined in) + +AnnotationAssertion(rdfs:comment SOMA:isEventTypeDefinedIn "A relation between an event type and a description, e.g. an event that is described by the Affordance of an object to be cut with a knife. + +The distinction to 'is task defined in' is necessary to let Dispositions and Affordances not only describe which tasks might be afforded by objects, but also whihc processes (where there is no agent). For example, the fall of a knife from a shelf slicing a loaf of bread on impact is , in the absence of an executing agent, not a task but merely a process, the possibility of which is nevertheless described by the dispositions of the knife and the loaf."@en) +AnnotationAssertion(rdfs:label SOMA:isEventTypeDefinedIn "is event type defined in"@en) +SubObjectPropertyOf(SOMA:isEventTypeDefinedIn ) +ObjectPropertyDomain(SOMA:isEventTypeDefinedIn ) +ObjectPropertyRange(SOMA:isEventTypeDefinedIn ) + # Object Property: SOMA:isInitialSituationOf (is initial situation of) -AnnotationAssertion(rdfs:comment SOMA:isInitialSituationOf "A relation between SituationTransitions and Situations, which identifies the Situation the transition starts from.") +AnnotationAssertion(rdfs:comment SOMA:isInitialSituationOf "A relation between SituationTransitions and Situations, which identifies the Situation the transition starts from."^^xsd:string) AnnotationAssertion(rdfs:label SOMA:isInitialSituationOf "is initial situation of"@en) -SubObjectPropertyOf(SOMA:isInitialSituationOf ) +SubObjectPropertyOf(SOMA:isInitialSituationOf SOMA:isInitialStateOf) ObjectPropertyDomain(SOMA:isInitialSituationOf ) ObjectPropertyRange(SOMA:isInitialSituationOf SOMA:SituationTransition) @@ -278,14 +333,53 @@ SubObjectPropertyOf(SOMA:isPerformedBy ) ObjectPropertyRange(SOMA:isPerformedBy ) +# Object Property: SOMA:isReactionTo (is reaction to) + +AnnotationAssertion(rdfs:comment SOMA:isReactionTo "Simple relationship between two actions to express that the subject (the reaction) would not have occured if it were not for the object (the cause), e.g., a Communication Action classified as an Answering Task is a reaction to another Communication Task classified as a Query Task and would not have occured without the other. An example without Agents involved would be some domino stone would not have toppled without the first one toppling. + +When Agents are involved, the relation might be seen as an abstraction of the execution of some plan that arises from changing the agents goal that is due to perceiving the cause. However, currently it is unclear how to model such a pattern and therefore not included in SOMA. + +This relation is seen as transitive."@en) +AnnotationAssertion(rdfs:label SOMA:isReactionTo "is reaction to") +SubObjectPropertyOf(SOMA:isReactionTo ) +TransitiveObjectProperty(SOMA:isReactionTo) +ObjectPropertyDomain(SOMA:isReactionTo ) +ObjectPropertyRange(SOMA:isReactionTo ) + +# Object Property: SOMA:isReplacedBy (is replaced by) + +AnnotationAssertion(rdfs:comment SOMA:isReplacedBy "The relation between a State that is replaced by another, e.g., the state of a bowl of fruits containing some objects is replaced by a new containment state when one object is taken away (in this example, we simplified the relation between the State and its type)."@en) +AnnotationAssertion(rdfs:label SOMA:isReplacedBy "is replaced by"@en) +SubObjectPropertyOf(SOMA:isReplacedBy SOMA:before) +InverseObjectProperties(SOMA:isReplacedBy SOMA:replaces) +ObjectPropertyDomain(SOMA:isReplacedBy SOMA:State) +ObjectPropertyRange(SOMA:isReplacedBy SOMA:State) + +# Object Property: SOMA:isTaskOfCreatedRole (is task of created role) + +AnnotationAssertion(rdfs:comment SOMA:isTaskOfCreatedRole "A relation between a Task and one of its output roles. The difference to IsTaskOfOutputRole is that the latter is also applicable, e.g., for Deciding between objects, where the selected object is not created, but still an outcome of that task.") +AnnotationAssertion(rdfs:label SOMA:isTaskOfCreatedRole "is task of created role") +SubObjectPropertyOf(SOMA:isTaskOfCreatedRole SOMA:isTaskOfOutputRole) +ObjectPropertyDomain(SOMA:isTaskOfCreatedRole ) +ObjectPropertyRange(SOMA:isTaskOfCreatedRole ) + # Object Property: SOMA:isTerminalSituationOf (is terminal situation of) -AnnotationAssertion(rdfs:comment SOMA:isTerminalSituationOf "A relation between SituationTransitions and Situations, which identifies the Situation the transition ends at.") +AnnotationAssertion(rdfs:comment SOMA:isTerminalSituationOf "A relation between SituationTransitions and Situations, which identifies the Situation the transition ends at."^^xsd:string) AnnotationAssertion(rdfs:label SOMA:isTerminalSituationOf "is terminal situation of"@en) -SubObjectPropertyOf(SOMA:isTerminalSituationOf ) +SubObjectPropertyOf(SOMA:isTerminalSituationOf SOMA:isTerminalStateOf) ObjectPropertyDomain(SOMA:isTerminalSituationOf ) ObjectPropertyRange(SOMA:isTerminalSituationOf SOMA:SituationTransition) +# Object Property: SOMA:isTerminatedBy (is terminated by) + +AnnotationAssertion(rdfs:comment SOMA:isTerminatedBy "The association between an Event that is terminated by another Event, e.g., the Action of picking an apple from a bowl of fruits terminates the State of containment between the apple and the bowl."@en) +AnnotationAssertion(rdfs:label SOMA:isTerminatedBy "is terminated by"@en) +SubObjectPropertyOf(SOMA:isTerminatedBy ) +InverseObjectProperties(SOMA:isTerminatedBy SOMA:terminates) +ObjectPropertyDomain(SOMA:isTerminatedBy ) +ObjectPropertyRange(SOMA:isTerminatedBy ) + # Object Property: SOMA:relatesToAnotherRole (relates to another role) AnnotationAssertion(rdfs:comment SOMA:relatesToAnotherRole "Simple top-level property for relations between two roles.") @@ -295,11 +389,30 @@ SymmetricObjectProperty(SOMA:relatesToAnotherRole) ObjectPropertyDomain(SOMA:relatesToAnotherRole ) ObjectPropertyRange(SOMA:relatesToAnotherRole ) -# Object Property: () +# Object Property: SOMA:replaces (replaces) + +AnnotationAssertion(rdfs:comment SOMA:replaces "The relation between a State that replaces another, e.g., the state of a bowl of fruits containing some objects is replaced by a new containment state when one object is taken away (in this example, we simplified the relation between the State and its type)."@en) +AnnotationAssertion(rdfs:label SOMA:replaces "replaces"@en) +SubObjectPropertyOf(SOMA:replaces SOMA:after) +ObjectPropertyDomain(SOMA:replaces SOMA:State) +ObjectPropertyRange(SOMA:replaces SOMA:State) + +# Object Property: SOMA:terminates (terminates) + +AnnotationAssertion(rdfs:comment SOMA:terminates "The association between an Event that terminates another Event, e.g., the Action of picking an apple from a bowl of fruits terminates the State of containment between the apple and the bowl."@en) +AnnotationAssertion(rdfs:label SOMA:terminates "terminates"@en) +SubObjectPropertyOf(SOMA:terminates ) +ObjectPropertyDomain(SOMA:terminates ) +ObjectPropertyRange(SOMA:terminates ) + +# Object Property: (has expected terminal situation) AnnotationAssertion(rdfs:comment "A relation between a Transition and the Situation it is expected to, and does actually, end at. You can assert this relationship when the observed outcome of a transition matches expectations.") +AnnotationAssertion(rdfs:label "has expected terminal situation"@en) SubObjectPropertyOf( SOMA:hasTerminalSituation) SubObjectPropertyOf( ) +ObjectPropertyDomain( SOMA:SituationTransition) +ObjectPropertyRange( ) # Object Property: (has required initial situation) @@ -307,6 +420,8 @@ AnnotationAssertion(rdfs:comment "has required initial situation"@en) SubObjectPropertyOf( SOMA:hasInitialSituation) SubObjectPropertyOf( ) +ObjectPropertyDomain( SOMA:SituationTransition) +ObjectPropertyRange( ) # Object Property: (manifests in) @@ -331,6 +446,10 @@ SubObjectPropertyOf( ) ObjectPropertyRange( ) +# Object Property: (defines task) + +SubObjectPropertyOf( SOMA:definesEventType) + # Object Property: (has postcondition) AnnotationAssertion(rdfs:comment "This should be taken to mean that the postcondition is the situation expected to follow the current situation. Whether the expectation is met is another issue.") @@ -339,19 +458,16 @@ AnnotationAssertion(rdfs:comment "This should be taken to mean: a precondition is a situation without which the current situation would not be possible.") +# Object Property: (is task defined in) + +SubObjectPropertyOf( SOMA:isEventTypeDefinedIn) + ############################ # Classes ############################ -# Class: :AnsweringTask (Answering task) - -AnnotationAssertion(rdfs:comment :AnsweringTask "An Illocutionary act where the Sender emits some Message to the Receiver as a reaction to some previous Communication task where the Roles where switched, i.e., the Sender (Receiver) of the Answering task has been the Sender (Sender) for the cause."@en) -AnnotationAssertion(rdfs:label :AnsweringTask "Answering task"@en) -EquivalentClasses(:AnsweringTask ObjectIntersectionOf(SOMA:IllocutionaryTask ObjectAllValuesFrom( ObjectAllValuesFrom(:isReactionTo ObjectSomeValuesFrom( SOMA:CommandingTask))))) -EquivalentClasses(:AnsweringTask ObjectSomeValuesFrom( SOMA:Answer)) - # Class: :Cleaning (:Cleaning) AnnotationAssertion(rdfs:comment :Cleaning "This task in which an agent restores all the objects to their destined locations, wiping a specific object"^^xsd:string) @@ -382,19 +498,6 @@ AnnotationAssertion(rdfs:comment :PouringOnto "The task in which an agent pours AnnotationAssertion(rdfs:label :PouringOnto "Pouring onto"^^xsd:string) SubClassOf(:PouringOnto :Pouring) -# Class: :QueryAnsweringTask (Query answering task) - -AnnotationAssertion(rdfs:comment :QueryAnsweringTask "An Answering task that is the reaction to some Query answering task. - -In a lot of cases, such a task is also an Assertion task, e.g., in the following discourse: - -\"How will the weather be tomorrow?\" -\"It is going to rain in the morning.\" - -However, sometimes this might be not the case, e.g., with counterquestions."@en) -AnnotationAssertion(rdfs:label :QueryAnsweringTask "Query answering task") -EquivalentClasses(:QueryAnsweringTask ObjectIntersectionOf(:AnsweringTask ObjectAllValuesFrom( ObjectAllValuesFrom(:isReactionTo ObjectSomeValuesFrom( SOMA:QueryingTask))))) - # Class: :Serving (:Serving) AnnotationAssertion(rdfs:comment :Serving "The task in which the agent delivers an object to a physical agent"^^xsd:string) @@ -431,10 +534,17 @@ SubClassOf(SOMA:Actuating SOMA:PhysicalTask) # Class: SOMA:Answer (Answer) -AnnotationAssertion(rdfs:comment SOMA:Answer "A role that is played by an Information Realization answering some query.") +AnnotationAssertion(rdfs:comment SOMA:Answer "A role that is played by an Information Realization answering some query."^^xsd:string) AnnotationAssertion(rdfs:label SOMA:Answer "Answer") SubClassOf(SOMA:Answer SOMA:Message) +# Class: SOMA:AnsweringTask (Answering task) + +AnnotationAssertion(rdfs:comment SOMA:AnsweringTask "An Illocutionary act where the Sender emits some Message to the Receiver as a reaction to some previous Communication task where the Roles where switched, i.e., the Sender (Receiver) of the Answering task has been the Sender (Sender) for the cause."@en) +AnnotationAssertion(rdfs:label SOMA:AnsweringTask "Answering task"@en) +EquivalentClasses(SOMA:AnsweringTask ObjectIntersectionOf(SOMA:IllocutionaryTask ObjectAllValuesFrom( ObjectAllValuesFrom(SOMA:isReactionTo ObjectSomeValuesFrom( SOMA:CommandingTask))))) +EquivalentClasses(SOMA:AnsweringTask ObjectSomeValuesFrom( SOMA:Answer)) + # Class: SOMA:AreaSurveying (Area surveying) AnnotationAssertion(rdfs:comment SOMA:AreaSurveying "A task in which an Agent uses its perception apparatus to gain information about some location.") @@ -469,11 +579,24 @@ AnnotationAssertion(rdfs:comment SOMA:AssumingPose "A task by which an Agent arr AnnotationAssertion(rdfs:label SOMA:AssumingPose "Assuming pose"@en) SubClassOf(SOMA:AssumingPose SOMA:PhysicalTask) +# Class: SOMA:AttentionShift (Attention shifting) + +AnnotationAssertion(rdfs:comment SOMA:AttentionShift "A mental task in which the executing Agent shifts his attention from some Information to another."@en) +AnnotationAssertion(rdfs:label SOMA:AttentionShift "Attention shifting"@en) +SubClassOf(SOMA:AttentionShift SOMA:MentalTask) + # Class: SOMA:Avoiding (SOMA:Avoiding) AnnotationAssertion(rdfs:comment SOMA:Avoiding "A task in which an Agent moves so as to not enter or pass through a location.") SubClassOf(SOMA:Avoiding SOMA:Navigating) +# Class: SOMA:Capability (SOMA:Capability) + +AnnotationAssertion(rdfs:comment SOMA:Capability "Capability") +AnnotationAssertion(rdfs:comment SOMA:Capability "The tendency of an object (the bearer) to be able to perform certain tasks together with others (the triggers) and in which the Bearer is the executor of the associated Task and will therefore usually be an Agent.") +SubClassOf(SOMA:Capability SOMA:Disposition) +SubClassOf(SOMA:Capability ObjectExactCardinality(1 ObjectIntersectionOf(SOMA:Affordance ObjectExactCardinality(1 SOMA:definesBearer ) ObjectExactCardinality(1 SOMA:definesTrigger ) ObjectExactCardinality(1 )))) + # Class: SOMA:Catching (SOMA:Catching) AnnotationAssertion(rdfs:comment SOMA:Catching "A task by which an Agent stops a moving object and gains kinematic control over it, usually by grasping.") @@ -547,9 +670,16 @@ AnnotationAssertion(rdfs:label SOMA:CommunicationTopic "Communication topic"@en) SubClassOf(SOMA:CommunicationTopic SOMA:ResourceRole) SubClassOf(SOMA:CommunicationTopic ObjectAllValuesFrom( ObjectIntersectionOf( ObjectSomeValuesFrom( ObjectSomeValuesFrom( SOMA:CommunicationTask))))) +# Class: SOMA:Conclusion (Conclusions) + +AnnotationAssertion(rdfs:comment SOMA:Conclusion "An object that is derived from some premise using some inference rules.") +AnnotationAssertion(rdfs:label SOMA:Conclusion "Conclusions") +SubClassOf(SOMA:Conclusion SOMA:CreatedObject) +SubClassOf(SOMA:Conclusion SOMA:Knowledge) + # Class: SOMA:Constructing (SOMA:Constructing) -AnnotationAssertion(rdfs:comment SOMA:Constructing "A task in which an Agent creates a new object.") +AnnotationAssertion(rdfs:comment SOMA:Constructing "A task in which an Agent creates a new physical object."@en) SubClassOf(SOMA:Constructing SOMA:PhysicalTask) DisjointClasses(SOMA:Constructing SOMA:ModifyingPhysicalObject) @@ -558,6 +688,12 @@ DisjointClasses(SOMA:Constructing SOMA:ModifyingPhysicalObject) AnnotationAssertion(rdfs:comment SOMA:Cutting "The goal of this task is to separate one or more pieces from some target object by means of cutting into its constituent material. Unlike a disassembly, a cut is usually not easily reversible.") SubClassOf(SOMA:Cutting SOMA:ModifyingPhysicalObject) +# Class: SOMA:Deciding (Deciding) + +AnnotationAssertion(rdfs:isDefinedBy SOMA:Deciding "A mental task in where an agent makes some decision, that is, selecting some Information object; usually on the basis of others."@en) +AnnotationAssertion(rdfs:label SOMA:Deciding "Deciding"@en) +SubClassOf(SOMA:Deciding SOMA:DerivingInformation) + # Class: SOMA:DeductiveReasoning (Deductive reasoning) AnnotationAssertion(rdfs:comment SOMA:DeductiveReasoning "A task in which the Agent, using general logical principles that it considers logically valid, applied to premises that it considers logically true, arrives at conclusions that it considers logically certain. @@ -578,11 +714,23 @@ DisjointClasses(SOMA:Delivering SOMA:Pulling) DisjointClasses(SOMA:Delivering SOMA:Pushing) DisjointClasses(SOMA:Delivering SOMA:Squeezing) +# Class: SOMA:DerivingInformation (Deriving information) + +AnnotationAssertion(rdfs:label SOMA:DerivingInformation "Deriving information") +SubClassOf(SOMA:DerivingInformation SOMA:InformationAcquisition) +SubClassOf(SOMA:DerivingInformation ObjectIntersectionOf(ObjectSomeValuesFrom(SOMA:isTaskOfInputRole SOMA:Premise) ObjectSomeValuesFrom(SOMA:isTaskOfOutputRole SOMA:Conclusion))) + # Class: SOMA:Dicing (SOMA:Dicing) AnnotationAssertion(rdfs:comment SOMA:Dicing "A particular kind of cutting where the goal is to produce small pieces out of some object or material. Unlike slices, the pieces to be obtained do not have one or two dimensions being more prominent than others. \"Dice\", the pieces dicing results in, are approximately cubic.") SubClassOf(SOMA:Dicing SOMA:Cutting) +# Class: SOMA:Discourse (Discourse) + +AnnotationAssertion(rdfs:comment SOMA:Discourse "A mental task, in which two or more agents discuss some topic via multiple Illocutionary acts, which are part of this task."@en) +AnnotationAssertion(rdfs:label SOMA:Discourse "Discourse"@en) +SubClassOf(SOMA:Discourse SOMA:CommunicationTask) + # Class: SOMA:Distancing (SOMA:Distancing) AnnotationAssertion(rdfs:comment SOMA:Distancing "A task in which an Agent increases its distance from some location.") @@ -591,7 +739,7 @@ SubClassOf(SOMA:Distancing SOMA:Navigating) # Class: SOMA:Dreaming (SOMA:Dreaming) AnnotationAssertion(rdfs:comment SOMA:Dreaming "Any form of re-processing episodic memories for long-term memory by natural or aritifical agents.") -SubClassOf(SOMA:Dreaming SOMA:MentalTask) +SubClassOf(SOMA:Dreaming SOMA:DerivingInformation) # Class: SOMA:Dropping (SOMA:Dropping) @@ -624,11 +772,29 @@ DisjointClasses(SOMA:Fetching SOMA:Pulling) DisjointClasses(SOMA:Fetching SOMA:Pushing) DisjointClasses(SOMA:Fetching SOMA:Squeezing) +# Class: SOMA:Focusing (Focusing) + +AnnotationAssertion(rdfs:comment SOMA:Focusing "The mental task to center the attention to some subject.") +AnnotationAssertion(rdfs:label SOMA:Focusing "Focusing") +SubClassOf(SOMA:Focusing SOMA:AttentionShift) + +# Class: SOMA:ForgettingIncorrectInformation (Forgetting incorrect information) + +AnnotationAssertion(rdfs:comment SOMA:ForgettingIncorrectInformation "A mental task in which the executing agent aims to correct its present information by deleting an incorrect information."@en) +AnnotationAssertion(rdfs:label SOMA:ForgettingIncorrectInformation "Forgetting incorrect information"@en) +SubClassOf(SOMA:ForgettingIncorrectInformation SOMA:InformationDismissal) + +# Class: SOMA:ForgettingIrrelevantInformation (Forgetting irrelevant information) + +AnnotationAssertion(rdfs:comment SOMA:ForgettingIrrelevantInformation "A mental task in which the executing agent aims to clean up its present information by deleting an irrelevant information."@en) +AnnotationAssertion(rdfs:label SOMA:ForgettingIrrelevantInformation "Forgetting irrelevant information"@en) +SubClassOf(SOMA:ForgettingIrrelevantInformation SOMA:InformationDismissal) + # Class: SOMA:GetTaskParameter (Get task parameter) AnnotationAssertion(rdfs:comment SOMA:GetTaskParameter "A task in which an Agent computes some parameter relevant for another task.") AnnotationAssertion(rdfs:label SOMA:GetTaskParameter "Get task parameter"@en) -SubClassOf(SOMA:GetTaskParameter SOMA:MentalTask) +SubClassOf(SOMA:GetTaskParameter SOMA:Planning) # Class: SOMA:GraspTransfer (Grasp transfer) @@ -660,7 +826,7 @@ SubClassOf(SOMA:IllocutionaryTask ObjectIntersectionOf(SOMA:CommunicationTask Ob # Class: SOMA:Imagining (SOMA:Imagining) AnnotationAssertion(rdfs:comment SOMA:Imagining "A Mental task in which the Agent constructs a mental representation of a possible world. An Agent performing an Imagining activity does not aim to construct a representation that aspires to be faithful to some past, present, or future state of affairs of the actual world it is embodied in.") -SubClassOf(SOMA:Imagining SOMA:MentalTask) +SubClassOf(SOMA:Imagining SOMA:InformationAcquisition) # Class: SOMA:InductiveReasoning (Inductive resoning) @@ -670,6 +836,86 @@ Induction is often described as a move from many \"specifics\" (swan A is white, AnnotationAssertion(rdfs:label SOMA:InductiveReasoning "Inductive resoning"@en) SubClassOf(SOMA:InductiveReasoning SOMA:Reasoning) +# Class: SOMA:InferenceRules (Inference rules) + +AnnotationAssertion(rdfs:comment SOMA:InferenceRules "The role of an object that is used to derive a conclusion from some premises.") +AnnotationAssertion(rdfs:label SOMA:InferenceRules "Inference rules") +SubClassOf(SOMA:InferenceRules SOMA:Knowledge) + +# Class: SOMA:InformationAcquisition (Information acquisition) + +AnnotationAssertion(rdfs:comment SOMA:InformationAcquisition "A mental task in which the executing agent acquires some information that was not immediately available to it before. +A synonym might be \"Thinking\". + +Examples include recalling knowledge or inferring some information from other information."@en) +AnnotationAssertion(rdfs:label SOMA:InformationAcquisition "Information acquisition"@en) +EquivalentClasses(SOMA:InformationAcquisition ObjectIntersectionOf(SOMA:MentalTask ObjectSomeValuesFrom(SOMA:isTaskOfOutputRole ObjectIntersectionOf(SOMA:CreatedObject SOMA:Knowledge)))) + +# Class: SOMA:InformationDismissal (Information dismissal) + +AnnotationAssertion(rdfs:comment SOMA:InformationDismissal "A mental task in which the executing agent dismisses some information. + +An example is forgetting some knowledge."@en) +AnnotationAssertion(rdfs:label SOMA:InformationDismissal "Information dismissal"@en) +SubClassOf(SOMA:InformationDismissal SOMA:MentalTask) +SubClassOf(SOMA:InformationDismissal ObjectSomeValuesFrom(SOMA:isTaskOfInputRole ObjectIntersectionOf(SOMA:DestroyedObject SOMA:Knowledge))) + +# Class: SOMA:InformationRetrieval (Information retrieval) + +AnnotationAssertion(rdfs:comment SOMA:InformationRetrieval "A mental task in which an Agent recalls some knowledge that has been memorized previously. + +Examples include a human remembering some information or a computer retrieving knowledge from a database. + +The difference to Remembering is that for this Task, we are concerned with knowledge about a previous world state. Memory Retrieval is more general in the sense that it also includes the retrieval of learned facts and rules."@en) +AnnotationAssertion(rdfs:label SOMA:InformationRetrieval "Information retrieval"@en) +SubClassOf(SOMA:InformationRetrieval SOMA:InformationAcquisition) +SubClassOf(SOMA:InformationRetrieval ObjectSomeValuesFrom(SOMA:isTaskOfOutputRole SOMA:Knowledge)) + +# Class: SOMA:InformationStorage (Information storage) + +AnnotationAssertion(rdfs:comment SOMA:InformationStorage "A mental task in which the executing agent persists some information for later recall, if necessary. + +An example is learning new knowledge."@en) +AnnotationAssertion(rdfs:label SOMA:InformationStorage "Information storage"@en) +SubClassOf(SOMA:InformationStorage SOMA:MentalTask) +SubClassOf(SOMA:InformationStorage ObjectSomeValuesFrom(SOMA:isTaskOfInputRole ObjectIntersectionOf( SOMA:Knowledge))) + +# Class: SOMA:Instructions (Instructions) + +AnnotationAssertion(rdfs:comment SOMA:Instructions "The role of a plan to follow during an execution task.") +AnnotationAssertion(rdfs:label SOMA:Instructions "Instructions") +SubClassOf(SOMA:Instructions SOMA:Item) + +# Class: SOMA:Interpreting (Interpreting) + +AnnotationAssertion(rdfs:comment SOMA:Interpreting "A task in which an Agent interpretes some information, e.g., makes sense of some incoming message or its visible surroundings."@en) +AnnotationAssertion(rdfs:label SOMA:Interpreting "Interpreting"@en) +SubClassOf(SOMA:Interpreting SOMA:DerivingInformation) + +# Class: SOMA:Introspecting (Introspecting) + +AnnotationAssertion(rdfs:comment SOMA:Introspecting "A mentalk task in which an Agent gathers and processes information about its own mental tasks via, e.g., Meta Reasoning."@en) +AnnotationAssertion(rdfs:label SOMA:Introspecting "Introspecting"@en) +SubClassOf(SOMA:Introspecting SOMA:InformationAcquisition) + +# Class: SOMA:Knowledge (SOMA:Knowledge) + +SubClassOf(SOMA:Knowledge SOMA:Item) + +# Class: SOMA:Labeling (Labeling) + +AnnotationAssertion(rdfs:label SOMA:Labeling "A task in which an agent annotates some objects with names, e.g., labeling the feeling of a tip-of-the-tongue event as such.") +AnnotationAssertion(rdfs:label SOMA:Labeling "Labeling") +SubClassOf(SOMA:Labeling SOMA:Interpreting) + +# Class: SOMA:Learning (Learning) + +AnnotationAssertion(rdfs:comment SOMA:Learning "The mental task of storing information for later use. + +This is more general than memorizing, as the later only captures declarative knowledge.") +AnnotationAssertion(rdfs:label SOMA:Learning "Learning") +SubClassOf(SOMA:Learning SOMA:InformationStorage) + # Class: SOMA:Lifting (SOMA:Lifting) AnnotationAssertion(rdfs:comment SOMA:Lifting "todo: how to distinguish from e.g. 'pushing from the table'") @@ -721,6 +967,14 @@ Note: we employ Manipulating here in its literal, original sense, of using hands SubClassOf(SOMA:Manipulating SOMA:PhysicalTask) SubClassOf(SOMA:Manipulating ObjectAllValuesFrom( SOMA:PhysicalAction)) +# Class: SOMA:Memorizing (Memorizing) + +AnnotationAssertion(rdfs:comment SOMA:Memorizing "An atomic mental task in which an Agent saves some (declarative) information for later retrieval. + +Examples include a student learning vocabularies or a computer saving some information to a database."@en) +AnnotationAssertion(rdfs:label SOMA:Memorizing "Memorizing"@en) +SubClassOf(SOMA:Memorizing SOMA:Learning) + # Class: SOMA:MentalAction (Mental action) AnnotationAssertion(rdfs:comment SOMA:MentalAction "An Event construed as the Agent participant affecting Entities that are representations of actual or potential Entities or Events in the physical world in which the Agent is embodied. These representations are maintained by the Agent participant in the 'Mental action' event. @@ -747,19 +1001,22 @@ SubClassOf(SOMA:Message SOMA:Item) SubClassOf(SOMA:Message ObjectSomeValuesFrom( SOMA:CommunicationTask)) SubClassOf(SOMA:Message ObjectAllValuesFrom( )) -# Class: SOMA:MetaCognitionEvaluationTopic (SOMA:MetaCognitionEvaluationTopic) +# Class: SOMA:MetaCognitionEvaluationTopic (Meta cognition evaluation topic) AnnotationAssertion(rdfs:comment SOMA:MetaCognitionEvaluationTopic "A topic used while an Agent describes its own cognitive processes and acions to evaluate them according to some metric.") +AnnotationAssertion(rdfs:label SOMA:MetaCognitionEvaluationTopic "Meta cognition evaluation topic") SubClassOf(SOMA:MetaCognitionEvaluationTopic SOMA:MetaCognitionTopic) -# Class: SOMA:MetaCognitionMemoryTopic (SOMA:MetaCognitionMemoryTopic) +# Class: SOMA:MetaCognitionMemoryTopic (Meta cognition memory topic) AnnotationAssertion(rdfs:comment SOMA:MetaCognitionMemoryTopic "A topic used while an Agent describes its own cognitive processes and actions, and which covers descriptions of what memories are involved in them.") +AnnotationAssertion(rdfs:label SOMA:MetaCognitionMemoryTopic "Meta cognition memory topic") SubClassOf(SOMA:MetaCognitionMemoryTopic SOMA:MetaCognitionTopic) -# Class: SOMA:MetaCognitionPlanningTopic (SOMA:MetaCognitionPlanningTopic) +# Class: SOMA:MetaCognitionPlanningTopic (Meta cognition planning topic) AnnotationAssertion(rdfs:comment SOMA:MetaCognitionPlanningTopic "A topic used while an Agent describes the planning it does for its own cognitive processes and actions.") +AnnotationAssertion(rdfs:label SOMA:MetaCognitionPlanningTopic "Meta cognition planning topic") SubClassOf(SOMA:MetaCognitionPlanningTopic SOMA:MetaCognitionTopic) # Class: SOMA:MetaCognitionTopic (SOMA:MetaCognitionTopic) @@ -767,6 +1024,18 @@ SubClassOf(SOMA:MetaCognitionPlanningTopic SOMA:MetaCognitionTopic) AnnotationAssertion(rdfs:comment SOMA:MetaCognitionTopic "A topic for a description that an Agent might make of its own cognitive processes and actions.") SubClassOf(SOMA:MetaCognitionTopic SOMA:ThinkAloudTopic) +# Class: SOMA:MetacognitiveControlling (Metacognitive controlling) + +AnnotationAssertion(rdfs:comment SOMA:MetacognitiveControlling "The concious or subconcious task to control the own mental processes, e.g., evaluating them and instructing the own mind to shift attention.") +AnnotationAssertion(rdfs:label SOMA:MetacognitiveControlling "Metacognitive controlling") +SubClassOf(SOMA:MetacognitiveControlling SOMA:MentalTask) + +# Class: SOMA:MetacognitiveMonitoring (Metacognitive monitoring) + +AnnotationAssertion(rdfs:comment SOMA:MetacognitiveMonitoring "The task to label the processes and states of the own mind, e.g., to interprete the feeling of knowing an information but not being able to retrieve it at the moment as a tip-of-the-tongue event.") +AnnotationAssertion(rdfs:label SOMA:MetacognitiveMonitoring "Metacognitive monitoring") +SubClassOf(SOMA:MetacognitiveMonitoring SOMA:Introspecting) + # Class: SOMA:Mixing (SOMA:Mixing) AnnotationAssertion(rdfs:comment SOMA:Mixing "A task by which an Agent combines several entities, such that the combination is difficult or in practice impossible to reverse.") @@ -816,7 +1085,7 @@ SubClassOf(SOMA:ParkingArms SOMA:AssumingArmPose) # Class: SOMA:Perceiving (SOMA:Perceiving) AnnotationAssertion(rdfs:comment SOMA:Perceiving "A task in which the Agent gathers and interprets sensor information about its surroundings.") -SubClassOf(SOMA:Perceiving SOMA:PhysicalTask) +SubClassOf(SOMA:Perceiving ObjectIntersectionOf(SOMA:InformationAcquisition SOMA:PhysicalTask)) # Class: SOMA:PhysicalAcquiring (Physical acquiring) @@ -830,8 +1099,8 @@ SubClassOf(SOMA:PhysicalAcquiring SOMA:ModifyingPhysicalObject) # Class: SOMA:PhysicalAction (Physical action) -AnnotationAssertion(rdfs:comment SOMA:PhysicalAction "An action performed by an agent by using its body in some way to interact with the physical world, e.g., through manipulation of objects, or by changing the posture.") -AnnotationAssertion(rdfs:label SOMA:PhysicalAction "Physical action") +AnnotationAssertion(rdfs:comment SOMA:PhysicalAction "An action performed by an agent by using its body in some way to interact with the physical world, e.g., through manipulation of objects, or by changing the posture."^^xsd:string) +AnnotationAssertion(rdfs:label SOMA:PhysicalAction "Physical action"^^xsd:string) SubClassOf(SOMA:PhysicalAction ) # Class: SOMA:PhysicalTask (Physical task) @@ -854,7 +1123,7 @@ SubClassOf(SOMA:Placing SOMA:PhysicalTask) # Class: SOMA:Planning (SOMA:Planning) AnnotationAssertion(rdfs:comment SOMA:Planning "A Mental task in which the Agent endeavours to create a sequence of actions for itself which, if followed, will bring about a particular state of affairs in the world. This particular state of affairs is known to the agent and is often called the goal state of the planning action. Planning commits itself to feasibility: the Agent attempts to find a sequence of actions that it believes it will actually be able to perform.") -SubClassOf(SOMA:Planning SOMA:Prospecting) +SubClassOf(SOMA:Planning SOMA:Deciding) SubClassOf(SOMA:Planning ObjectSomeValuesFrom( ObjectSomeValuesFrom( ))) # Class: SOMA:Positioning (SOMA:Positioning) @@ -862,11 +1131,18 @@ SubClassOf(SOMA:Planning ObjectSomeValuesFrom( ObjectAllValuesFrom(SOMA:isReactionTo ObjectSomeValuesFrom( SOMA:QueryingTask))))) + # Class: SOMA:QueryingTask (Querying task) AnnotationAssertion(rdfs:comment SOMA:QueryingTask "An Illocutionary act where the Sender of the Message does so to trigger the Receiver to return some information that is specified within the content of the Message.") @@ -937,13 +1226,13 @@ Both Abductive and Inductive inference may, and often do, use Probabilistic meth Any of the Abductive/Deductive/Inductive triad can be further affected by the Monotone/Non-monotone distinction. There are preferences (Inductive and Abductive reasoning is probably most often non-monotonic; most of Deductive reasoning is probably done in monotonic formalisms), but it is certainly the case that, e.g., non-monotone Deduction is possible. Note, this classification has nothing to do with reasoning domain (e.g. SpatialReasoning, TemporalReasoning, ...) and merely with techniques/logical-mathematical underpinnings.") -SubClassOf(SOMA:Reasoning SOMA:MentalTask) +SubClassOf(SOMA:Reasoning SOMA:DerivingInformation) # Class: SOMA:Receiver (Receiver) AnnotationAssertion(rdfs:comment SOMA:Receiver "The role played by an Agent in a Communication Task that perceives and interpretes some incoming Message."@en) AnnotationAssertion(rdfs:label SOMA:Receiver "Receiver"@en) -SubClassOf(SOMA:Receiver SOMA:AgentRole) +SubClassOf(SOMA:Receiver SOMA:ExperiencerRole) SubClassOf(SOMA:Receiver ObjectSomeValuesFrom( SOMA:CommunicationTask)) # Class: SOMA:Releasing (SOMA:Releasing) @@ -953,8 +1242,18 @@ SubClassOf(SOMA:Releasing SOMA:Manipulating) # Class: SOMA:Remembering (SOMA:Remembering) -AnnotationAssertion(rdfs:comment SOMA:Remembering "A Mental task in which the Agent endeavours to recall a record of a previous state of affairs in the world. The Agent must have witnessed this state of affairs in order to record it. Remembering commits itself to accuracy: the Agent attempts to reconstruct as accurate a record as it can. Note, this does not mean the Agent will communicate the recollection accurately.") -SubClassOf(SOMA:Remembering SOMA:Retrospecting) +AnnotationAssertion(rdfs:comment SOMA:Remembering "A Mental task in which the Agent recalls a record of a previous state of affairs in the world. + +The Agent must have witnessed and memorized this state of affairs in order to record it. Remembering commits itself to accuracy: the Agent attempts to reconstruct as accurate a record as it can. Note, this does not mean the Agent will communicate the recollection accurately. + +The difference to Memory retrieval is that for this Task, we are concerned with knowledge about a previous world state. Memory Retrieval is more general in the sense that it also includes the retrieval of learned facts and rules."@en) +SubClassOf(SOMA:Remembering ObjectIntersectionOf(SOMA:InformationRetrieval SOMA:Retrospecting)) + +# Class: SOMA:Replanning (Replanning) + +AnnotationAssertion(rdfs:comment SOMA:Replanning "A mental task, in which an agent reconfigures some plan that has been put together before."@en) +AnnotationAssertion(rdfs:label SOMA:Replanning "Replanning"@en) +SubClassOf(SOMA:Replanning SOMA:Planning) # Class: SOMA:Retracting (SOMA:Retracting) @@ -967,7 +1266,7 @@ AnnotationAssertion(rdfs:comment SOMA:Retrospecting "A Mental task in which an A AnnotationAssertion(rdfs:comment SOMA:Retrospecting "Done by analogy with Prospecting. Currently mono-subcategory, but perhaps we might find more. As an example, a kind of Abductive reasoning would fit here: reconstruction, in which the agent attempts to create a representation of a past state of affairs which the agent has not actually observed, based on traces and clues surviving to the present.") -SubClassOf(SOMA:Retrospecting SOMA:MentalTask) +SubClassOf(SOMA:Retrospecting SOMA:InformationAcquisition) # Class: SOMA:SelectingItem (Selecting item) @@ -976,11 +1275,17 @@ AnnotationAssertion(rdfs:label SOMA:SelectingItem "Selecting item"@en) SubClassOf(SOMA:SelectingItem SOMA:GetTaskParameter) SubClassOf(SOMA:SelectingItem ObjectSomeValuesFrom(SOMA:isTaskOfOutputRole ObjectIntersectionOf(SOMA:SelectedObject ObjectAllValuesFrom( )))) +# Class: SOMA:SelfReflection (Self-reflection) + +AnnotationAssertion(rdfs:label SOMA:SelfReflection "Self-reflection") +AnnotationAssertion(rdfs:label SOMA:SelfReflection "The task of evaluating the personal cognitive processes.") +SubClassOf(SOMA:SelfReflection SOMA:MetacognitiveControlling) + # Class: SOMA:Sender (Sender) AnnotationAssertion(rdfs:comment SOMA:Sender "The Role played by an Agent in a Communication Task that emits some Information Realization with the purpose of percipience by some Receiver."@en) AnnotationAssertion(rdfs:label SOMA:Sender "Sender"@en) -SubClassOf(SOMA:Sender SOMA:AgentRole) +SubClassOf(SOMA:Sender SOMA:PerformerRole) SubClassOf(SOMA:Sender ObjectSomeValuesFrom( SOMA:CommunicationTask)) # Class: SOMA:SettingGripper (Setting gripper) @@ -1018,44 +1323,52 @@ AnnotationAssertion(rdfs:comment SOMA:ThinkAloud "A task in which an Agent, whil AnnotationAssertion(rdfs:label SOMA:ThinkAloud "Think-aloud"@en) SubClassOf(SOMA:ThinkAloud SOMA:CommunicationReport) -# Class: SOMA:ThinkAloudActionTopic (SOMA:ThinkAloudActionTopic) +# Class: SOMA:ThinkAloudActionTopic (Think aloud action topic) AnnotationAssertion(rdfs:comment SOMA:ThinkAloudActionTopic "A topic used when an Agent states what they are doing.") +AnnotationAssertion(rdfs:label SOMA:ThinkAloudActionTopic "Think aloud action topic") SubClassOf(SOMA:ThinkAloudActionTopic SOMA:ThinkAloudTopic) -# Class: SOMA:ThinkAloudGeneralKnowledgeTopic (SOMA:ThinkAloudGeneralKnowledgeTopic) +# Class: SOMA:ThinkAloudGeneralKnowledgeTopic (Think aloud general knowledge topic) AnnotationAssertion(rdfs:comment SOMA:ThinkAloudGeneralKnowledgeTopic "A topic used when an Agent states general knowledge they have.") +AnnotationAssertion(rdfs:label SOMA:ThinkAloudGeneralKnowledgeTopic "Think aloud general knowledge topic") SubClassOf(SOMA:ThinkAloudGeneralKnowledgeTopic SOMA:ThinkAloudKnowledgeTopic) -# Class: SOMA:ThinkAloudKnowledgeTopic (SOMA:ThinkAloudKnowledgeTopic) +# Class: SOMA:ThinkAloudKnowledgeTopic (Think aloud knowledge topic) AnnotationAssertion(rdfs:comment SOMA:ThinkAloudKnowledgeTopic "A topic used when an Agent states some item of knowledge. This knowledge can be general, or specific to the environment and task at hand.") +AnnotationAssertion(rdfs:label SOMA:ThinkAloudKnowledgeTopic "Think aloud knowledge topic") SubClassOf(SOMA:ThinkAloudKnowledgeTopic SOMA:ThinkAloudTopic) -# Class: SOMA:ThinkAloudObstructionTopic (SOMA:ThinkAloudObstructionTopic) +# Class: SOMA:ThinkAloudObstructionTopic (Think aloud obstruction topic) AnnotationAssertion(rdfs:comment SOMA:ThinkAloudObstructionTopic "A topic used when an Agent describes some state of affairs that prevents them from performing an action.") +AnnotationAssertion(rdfs:label SOMA:ThinkAloudObstructionTopic "Think aloud obstruction topic") SubClassOf(SOMA:ThinkAloudObstructionTopic SOMA:ThinkAloudTopic) -# Class: SOMA:ThinkAloudOpinionTopic (SOMA:ThinkAloudOpinionTopic) +# Class: SOMA:ThinkAloudOpinionTopic (Think aloud opinion topic) AnnotationAssertion(rdfs:comment SOMA:ThinkAloudOpinionTopic "A topic used when an Agent expresses an opinion about the action they perform or the environment they are in.") +AnnotationAssertion(rdfs:label SOMA:ThinkAloudOpinionTopic "Think aloud opinion topic") SubClassOf(SOMA:ThinkAloudOpinionTopic SOMA:ThinkAloudTopic) -# Class: SOMA:ThinkAloudPerceptionTopic (SOMA:ThinkAloudPerceptionTopic) +# Class: SOMA:ThinkAloudPerceptionTopic (Think aloud perception topic) AnnotationAssertion(rdfs:comment SOMA:ThinkAloudPerceptionTopic "A topic used when an Agent describes what they currently perceive.") +AnnotationAssertion(rdfs:label SOMA:ThinkAloudPerceptionTopic "Think aloud perception topic") SubClassOf(SOMA:ThinkAloudPerceptionTopic SOMA:ThinkAloudTopic) -# Class: SOMA:ThinkAloudPlanTopic (SOMA:ThinkAloudPlanTopic) +# Class: SOMA:ThinkAloudPlanTopic (Think aloud plan topic) AnnotationAssertion(rdfs:comment SOMA:ThinkAloudPlanTopic "A topic used when an Agent describes what they intend to do. Note, this is not about describing the process through which this plan was constructed; that is covered by the MetaCognitionPlanningTopic.") +AnnotationAssertion(rdfs:label SOMA:ThinkAloudPlanTopic "Think aloud plan topic") SubClassOf(SOMA:ThinkAloudPlanTopic SOMA:ThinkAloudTopic) -# Class: SOMA:ThinkAloudSceneKnowledgeTopic (SOMA:ThinkAloudSceneKnowledgeTopic) +# Class: SOMA:ThinkAloudSceneKnowledgeTopic (Think aloud scene knowledge topic) AnnotationAssertion(rdfs:comment SOMA:ThinkAloudSceneKnowledgeTopic "A topic used when an Agent describes what they know about their environment, including knowledge of world states that they do not currently perceive.") +AnnotationAssertion(rdfs:label SOMA:ThinkAloudSceneKnowledgeTopic "Think aloud scene knowledge topic") SubClassOf(SOMA:ThinkAloudSceneKnowledgeTopic SOMA:ThinkAloudKnowledgeTopic) # Class: SOMA:ThinkAloudTopic (Think aloud topic) @@ -1132,4 +1445,9 @@ SubClassOf(Annotation(rdfs:comment "If something is an initial situation of some SubClassOf(Annotation(rdfs:comment "If a transition has an initial situation then it also has a manifestation.") ObjectSomeValuesFrom(SOMA:hasInitialSituation ) ObjectSomeValuesFrom( )) SubClassOf(Annotation(rdfs:comment "If something is a terminal situation then it must be a manifested situation (regardless of whether it was expected or not).") ObjectSomeValuesFrom(SOMA:hasTerminalSituation ) owl:Nothing) SubClassOf(Annotation(rdfs:comment "If a transition has a terminal situation then it also has a manifestation.") ObjectSomeValuesFrom(SOMA:hasTerminalSituation ) ObjectSomeValuesFrom( )) +SubObjectPropertyOf(ObjectPropertyChain(SOMA:causesTransition SOMA:hasInitialSituation ) SOMA:terminates) +SubObjectPropertyOf(ObjectPropertyChain(SOMA:causesTransition SOMA:hasTerminalScene ) SOMA:directlyCauses) +SubObjectPropertyOf(ObjectPropertyChain( SOMA:hasInitialSituation SOMA:hasTerminalSituation ) SOMA:isReplacedBy) +SubObjectPropertyOf(ObjectPropertyChain( SOMA:hasTerminalSituation SOMA:hasInitialSituation ) SOMA:replaces) +SubObjectPropertyOf(ObjectPropertyChain( SOMA:isInputRoleOf SOMA:isTaskOfCreatedRole ) SOMA:isDirectSourceFor) ) \ No newline at end of file diff --git a/owl/SOMA-IO.owl b/owl/SOMA-IO.owl index 03a3cef6..f76ac419 100755 --- a/owl/SOMA-IO.owl +++ b/owl/SOMA-IO.owl @@ -22,10 +22,10 @@ Declaration(Class(SOMA:Algorithm)) Declaration(Class(SOMA:ArchiveFile)) Declaration(Class(SOMA:ArchiveFormat)) Declaration(Class(SOMA:ArchiveText)) -Declaration(Class(SOMA:ArtificialAgent)) Declaration(Class(SOMA:Classifier)) Declaration(Class(SOMA:Client-Server_Specification)) Declaration(Class(SOMA:ClientRole)) +Declaration(Class(SOMA:CognitiveAgent)) Declaration(Class(SOMA:Computer_Language)) Declaration(Class(SOMA:Computer_Program)) Declaration(Class(SOMA:Database)) @@ -71,6 +71,7 @@ Declaration(Class(SOMA:Software_Configuration)) Declaration(Class(SOMA:Source_Code)) Declaration(Class(SOMA:StatisticalReasoner)) Declaration(Class(SOMA:Structured_Text)) +Declaration(Class(SOMA:SubCognitiveAgent)) Declaration(Class(SOMA:SymbolicReasoner)) Declaration(Class(SOMA:System)) Declaration(Class(SOMA:Text)) @@ -86,7 +87,7 @@ Declaration(ObjectProperty(SOMA:isGivenMeaningBy)) # Object Properties ############################ -# Object Property: () +# Object Property: SOMA:encodes (SOMA:encodes) AnnotationAssertion(rdfs:comment SOMA:encodes "The relation between two Information Objects that have the same meaning, but are formatted differently. E.g., a text written in UTF-8 encodes a text in a natural writing system (letters) and vice versa."@en) SubObjectPropertyOf(SOMA:encodes ) @@ -94,37 +95,37 @@ SymmetricObjectProperty(SOMA:encodes) ObjectPropertyDomain(SOMA:encodes ) ObjectPropertyRange(SOMA:encodes ) -# Object Property: (The relation between a System and Information Object that is given meaning to by said system, e.g., a Language might give meaning to some word, sentence, text, etc., but without the knowledge of said System (Language), the text will not make sense to a reader.) +# Object Property: SOMA:givesMeaningTo (gives meaning to) -AnnotationAssertion(rdfs:label SOMA:givesMeaningTo "The relation between a System and Information Object that is given meaning to by said system, e.g., a Language might give meaning to some word, sentence, text, etc., but without the knowledge of said System (Language), the text will not make sense to a reader."@en) +AnnotationAssertion(rdfs:comment SOMA:givesMeaningTo "The relation between a System and Information Object that is given meaning to by said system, e.g., a Language might give meaning to some word, sentence, text, etc., but without the knowledge of said System (Language), the text will not make sense to a reader."@en) AnnotationAssertion(rdfs:label SOMA:givesMeaningTo "gives meaning to"@en) SubObjectPropertyOf(SOMA:givesMeaningTo ) InverseObjectProperties(SOMA:givesMeaningTo SOMA:isGivenMeaningBy) ObjectPropertyDomain(SOMA:givesMeaningTo SOMA:System) ObjectPropertyRange(SOMA:givesMeaningTo ) -# Object Property: (has software agent) +# Object Property: SOMA:hasSoftwareAgent (has software agent) ObjectPropertyRange(SOMA:hasSoftwareAgent SOMA:SoftwareInstance) -# Object Property: (is design for) +# Object Property: SOMA:isDesignFor (is design for) -AnnotationAssertion(rdfs:comment SOMA:isDesignFor "A special relation between a Design and a DesignedArtifact, to indicate that the Design describes a way to construct the DesignedArtifact."@en) +AnnotationAssertion(rdfs:comment SOMA:isDesignFor "A special relation between a Design and an Object, to indicate that the Design describes a way to construct the Object."@en) AnnotationAssertion(rdfs:label SOMA:isDesignFor "is design for"@en) SubObjectPropertyOf(SOMA:isDesignFor ) InverseObjectProperties(SOMA:isDesignFor SOMA:isDesignedBy) ObjectPropertyDomain(SOMA:isDesignFor ) -ObjectPropertyRange(SOMA:isDesignFor ) +ObjectPropertyRange(SOMA:isDesignFor ) -# Object Property: (is designed by) +# Object Property: SOMA:isDesignedBy (is designed by) -AnnotationAssertion(rdfs:comment SOMA:isDesignedBy "A special relation between a Design and a Designed Artifact, to indicate that the Designed Artifact is described by the Design."@en) +AnnotationAssertion(rdfs:comment SOMA:isDesignedBy "A special relation between a Design and an Object, to indicate that the Object is described by the Design."@en) AnnotationAssertion(rdfs:label SOMA:isDesignedBy "is designed by"@en) SubObjectPropertyOf(SOMA:isDesignedBy ) -ObjectPropertyDomain(SOMA:isDesignedBy ) +ObjectPropertyDomain(SOMA:isDesignedBy ) ObjectPropertyRange(SOMA:isDesignedBy ) -# Object Property: (is given meaning by) +# Object Property: SOMA:isGivenMeaningBy (is given meaning by) AnnotationAssertion(rdfs:comment SOMA:isGivenMeaningBy "The relation between an Information Object and a System that gives meaning to said object, e.g., a word, sentence, text, etc. might be given meaning by a Language and without the knowledge of said System (Language), the text will not make sense to a reader."@en) AnnotationAssertion(rdfs:label SOMA:isGivenMeaningBy "is given meaning by"@en) @@ -147,7 +148,7 @@ SubObjectPropertyOf( (API Specification) +# Class: SOMA:API_Specification (API Specification) AnnotationAssertion(rdfs:comment SOMA:API_Specification "An application programming interface (API) is a way for two or more computer programs to communicate with each other. It is a type of software interface, offering a service to other pieces of software. A document or standard that describes how to build or use an API is called an API specification. @@ -155,7 +156,7 @@ Source: https://en.wikipedia.org/wiki/API"@en) AnnotationAssertion(rdfs:label SOMA:API_Specification "API Specification"@en) SubClassOf(SOMA:API_Specification SOMA:InterfaceSpecification) -# Class: (Algorithm) +# Class: SOMA:Algorithm (Algorithm) AnnotationAssertion(rdfs:comment SOMA:Algorithm "An Algorithm is a finite sequence of well-defined instructions, typically used to solve a class of specific problems or to perform a computation. @@ -163,7 +164,7 @@ From Wikipedia: https://en.wikipedia.org/wiki/Algorithm"@en) AnnotationAssertion(rdfs:label SOMA:Algorithm "Algorithm"@en) SubClassOf(SOMA:Algorithm ) -# Class: (Archive File) +# Class: SOMA:ArchiveFile (Archive File) AnnotationAssertion(rdfs:comment SOMA:ArchiveFile "An archive file is a computer file that is composed of one or more files along with metadata. @@ -172,7 +173,7 @@ AnnotationAssertion(rdfs:label SOMA:ArchiveFile "Archive File") EquivalentClasses(SOMA:ArchiveFile ObjectIntersectionOf(SOMA:Digital_File ObjectSomeValuesFrom( SOMA:ArchiveText))) SubClassOf(SOMA:ArchiveFile SOMA:Digital_File) -# Class: (Archive Format) +# Class: SOMA:ArchiveFormat (Archive Format) AnnotationAssertion(rdfs:comment SOMA:ArchiveFormat "An Archive Format is the file format of an archive file. @@ -181,7 +182,7 @@ AnnotationAssertion(rdfs:label SOMA:ArchiveFormat "Archive Format"@en) SubClassOf(SOMA:ArchiveFormat SOMA:File_format) SubClassOf(SOMA:ArchiveFormat ObjectAllValuesFrom(SOMA:givesMeaningTo SOMA:ArchiveText)) -# Class: (Archive Text) +# Class: SOMA:ArchiveText (Archive Text) AnnotationAssertion(rdfs:comment SOMA:ArchiveText "An Archive is a Structured Text that is composed of one or more Structured Texts along with metadata. Archives are used to collect multiple texts together into a single text for easier portability and storage as Archive Files, or simply to compress text to use less storage space as Computer Files. Archive often store directory structures, error detection and correction information, arbitrary comments, and sometimes use built-in encryption. @@ -190,24 +191,14 @@ AnnotationAssertion(rdfs:label SOMA:ArchiveText "Archive Text"@en) EquivalentClasses(SOMA:ArchiveText ObjectIntersectionOf(SOMA:Structured_Text ObjectSomeValuesFrom( SOMA:FileConfiguration))) EquivalentClasses(SOMA:ArchiveText ObjectSomeValuesFrom(SOMA:isGivenMeaningBy SOMA:ArchiveFormat)) -# Class: (Artificial agent) - -AnnotationAssertion(rdfs:comment SOMA:ArtificialAgent "Any constructed agent with physical embodiment that has intentions on its own, e.g., a robot."@en) -AnnotationAssertion(rdfs:label SOMA:ArtificialAgent "Artificial agent"@en) -SubClassOf(SOMA:ArtificialAgent ) - -# Class: (Classifier) +# Class: SOMA:Classifier (Classifier) AnnotationAssertion(rdfs:label SOMA:Classifier "Classifier"@en) SubClassOf(SOMA:Classifier SOMA:StatisticalReasoner) -# Class: (An API Secification that describes the well known Client-Server pattern: -# -# The Client-server model is a distributed application structure that partitions tasks or workloads between the providers of a resource or service, called servers, and service requesters, called clients Often clients and servers communicate over a computer network on separate hardware, but both client and server may reside in the same system. A server host runs one or more server programs, which share their resources with clients. A client usually does not share any of its resources, but it requests content or service from a server. Clients, therefore, initiate communication sessions with servers, which await incoming requests. Examples of computer applications that use the client-server model are email, network printing, and the World Wide Web. -# -# Source: https://en.wikipedia.org/wiki/Client%E2%80%93server_model) +# Class: SOMA:Client-Server_Specification (Client-Server Specification) -AnnotationAssertion(rdfs:label SOMA:Client-Server_Specification "An API Secification that describes the well known Client-Server pattern: +AnnotationAssertion(rdfs:comment SOMA:Client-Server_Specification "An API Secification that describes the well known Client-Server pattern: The Client-server model is a distributed application structure that partitions tasks or workloads between the providers of a resource or service, called servers, and service requesters, called clients Often clients and servers communicate over a computer network on separate hardware, but both client and server may reside in the same system. A server host runs one or more server programs, which share their resources with clients. A client usually does not share any of its resources, but it requests content or service from a server. Clients, therefore, initiate communication sessions with servers, which await incoming requests. Examples of computer applications that use the client-server model are email, network printing, and the World Wide Web. @@ -216,7 +207,7 @@ AnnotationAssertion(rdfs:label SOMA:Client-Server_Specification "Client-Server S SubClassOf(SOMA:Client-Server_Specification SOMA:InterfaceSpecification) SubClassOf(SOMA:Client-Server_Specification ObjectIntersectionOf(ObjectSomeValuesFrom( SOMA:ClientRole) ObjectSomeValuesFrom( SOMA:ServerRole))) -# Class: (Client role) +# Class: SOMA:ClientRole (Client role) AnnotationAssertion(rdfs:comment SOMA:ClientRole "The Client-server model is a distributed application structure that partitions tasks or workloads between the providers of a resource or service, called servers, and service requesters, called clients Often clients and servers communicate over a computer network on separate hardware, but both client and server may reside in the same system. A server host runs one or more server programs, which share their resources with clients. A client usually does not share any of its resources, but it requests content or service from a server. Clients, therefore, initiate communication sessions with servers, which await incoming requests. Examples of computer applications that use the client-server model are email, network printing, and the World Wide Web. @@ -225,7 +216,14 @@ AnnotationAssertion(rdfs:label SOMA:ClientRole "Client role"@en) SubClassOf(SOMA:ClientRole SOMA:InterfaceComponentRole) SubClassOf(SOMA:ClientRole ObjectSomeValuesFrom( SOMA:Client-Server_Specification)) -# Class: (Computer Language) +# Class: SOMA:CognitiveAgent (cognitive agent) + +AnnotationAssertion(rdfs:comment SOMA:CognitiveAgent "An agent that is capable to act on its own, in contrast to sub-cognitive Agents, that need to have their intentionality bestowed upon some other agent."@en) +AnnotationAssertion(rdfs:label SOMA:CognitiveAgent "cognitive agent"@en) +SubClassOf(SOMA:CognitiveAgent ) +DisjointClasses(SOMA:CognitiveAgent SOMA:SubCognitiveAgent) + +# Class: SOMA:Computer_Language (Computer Language) AnnotationAssertion(rdfs:comment SOMA:Computer_Language "A computer language is a formal language used in communication with a computer. @@ -233,21 +231,21 @@ From Wikipedia: https://en.wikipedia.org/wiki/Computer_language"@en) AnnotationAssertion(rdfs:label SOMA:Computer_Language "Computer Language"@en) SubClassOf(SOMA:Computer_Language SOMA:FormalLanguage) -# Class: (Computer program) +# Class: SOMA:Computer_Program (Computer program) AnnotationAssertion(rdfs:comment SOMA:Computer_Program "The Program itself (the specific set of instruction in a Programming Language), not the file that it is contained in nor the implemented algorithm!"@en) AnnotationAssertion(rdfs:label SOMA:Computer_Program "Computer program"@en) EquivalentClasses(SOMA:Computer_Program ObjectIntersectionOf(SOMA:Structured_Text ObjectSomeValuesFrom(SOMA:isGivenMeaningBy SOMA:Programming_Language))) EquivalentClasses(SOMA:Computer_Program ObjectIntersectionOf(SOMA:Structured_Text ObjectSomeValuesFrom( SOMA:Algorithm))) -# Class: () +# Class: SOMA:Database (SOMA:Database) AnnotationAssertion(rdfs:comment SOMA:Database "A Database is a Software that organizes a collection of data stored and and allows for access, usually via some query engine. Source: https://en.wikipedia.org/wiki/Database"@en) SubClassOf(SOMA:Database SOMA:SoftwareRole) -# Class: (Computer File) +# Class: SOMA:Digital_File (Computer File) AnnotationAssertion(rdfs:comment SOMA:Digital_File "Any file that exists as a digital resource (but not its content), e.g., a text file actually laying on some hard drive, but not the contained text."@en) AnnotationAssertion(rdfs:label SOMA:Digital_File "Computer File"@en) @@ -256,7 +254,7 @@ SubClassOf(SOMA:Digital_File SOMA:Structured_Text)) SubClassOf(Annotation(rdfs:comment "The path of the file on a computer system."@en) SOMA:Digital_File DataSomeValuesFrom(SOMA:hasNameString xsd:string)) -# Class: (Executable File) +# Class: SOMA:ExecutableFile (Executable File) AnnotationAssertion(rdfs:comment SOMA:ExecutableFile "An Executable File, sometimes simply referred to as an executable or binary, causes a computer \"to perform indicated tasks according to encoded instructions\", as opposed to a data file that must be interpreted (parsed) by a program to be meaningful. @@ -264,39 +262,39 @@ The exact interpretation depends upon the use. \"Instructions\" is traditionally AnnotationAssertion(rdfs:label SOMA:ExecutableFile "Executable File"@en) EquivalentClasses(SOMA:ExecutableFile ObjectIntersectionOf(SOMA:Digital_File ObjectSomeValuesFrom( SOMA:Executable_Code))) -# Class: (Executable Format) +# Class: SOMA:ExecutableFormat (Executable Format) AnnotationAssertion(rdfs:comment SOMA:ExecutableFormat "An Executable Format is a File Format that allows computers to directly execute the content. Examples are MZ (DOS) or COFF."@en) AnnotationAssertion(rdfs:label SOMA:ExecutableFormat "Executable Format"@en) SubClassOf(SOMA:ExecutableFormat SOMA:File_format) SubClassOf(SOMA:ExecutableFormat ObjectAllValuesFrom(SOMA:givesMeaningTo SOMA:Executable_Code)) -# Class: (Executable Software) +# Class: SOMA:ExecutableSoftware (Executable Software) AnnotationAssertion(rdfs:comment SOMA:ExecutableSoftware "Executable Software is Software that can directly be executed, in comparison to a Software Library, which might only contain functionality via interfaces, but offers no execution entry point."@en) AnnotationAssertion(rdfs:label SOMA:ExecutableSoftware "Executable Software"@en) EquivalentClasses(SOMA:ExecutableSoftware ObjectIntersectionOf(SOMA:Software ObjectSomeValuesFrom( SOMA:ExecutableFile))) -# Class: (Executable Code) +# Class: SOMA:Executable_Code (Executable Code) AnnotationAssertion(rdfs:comment SOMA:Executable_Code "Executable Code is Code that when compiled / interpreted, has some clear entrance point and can be executed. Note the difference to an Executable File, which is the file that contains such (compiled) code."@en) AnnotationAssertion(rdfs:label SOMA:Executable_Code "Executable Code"@en) EquivalentClasses(SOMA:Executable_Code ObjectIntersectionOf(SOMA:Computer_Program ObjectSomeValuesFrom(SOMA:isGivenMeaningBy SOMA:ExecutableFormat))) SubClassOf(SOMA:Executable_Code SOMA:Computer_Program) -# Class: (Faulty software) +# Class: SOMA:FaultySoftware (Faulty software) AnnotationAssertion(rdfs:comment SOMA:FaultySoftware "A description of a situation where some software has a bug.") AnnotationAssertion(rdfs:label SOMA:FaultySoftware "Faulty software"@en) SubClassOf(SOMA:FaultySoftware SOMA:SoftwareDiagnosis) -# Class: (File Configuration) +# Class: SOMA:FileConfiguration (File Configuration) AnnotationAssertion(rdfs:comment SOMA:FileConfiguration "A configuration whose members are all files. Used to model, e.g., concrete collections of zip- and jar-files (and so on)."@en) AnnotationAssertion(rdfs:label SOMA:FileConfiguration "File Configuration"@en) EquivalentClasses(SOMA:FileConfiguration ObjectIntersectionOf( ObjectAllValuesFrom( SOMA:Digital_File))) -# Class: (File Format) +# Class: SOMA:File_format (File Format) AnnotationAssertion(rdfs:comment SOMA:File_format "A File Format is a standard way that information is encoded for storage in a computer file. It specifies how bits are used to encode information in a digital storage medium. @@ -304,7 +302,7 @@ From Wikipedia: https://en.wikipedia.org/wiki/File_format"@en) AnnotationAssertion(rdfs:label SOMA:File_format "File Format"@en) SubClassOf(SOMA:File_format SOMA:Computer_Language) -# Class: (Formal Language) +# Class: SOMA:FormalLanguage (Formal Language) AnnotationAssertion(rdfs:comment SOMA:FormalLanguage "A Formal Language consists of words whose letters are taken from an alphabet and are well-formed according to a specific set of rules. @@ -313,19 +311,19 @@ AnnotationAssertion(rdfs:label SOMA:FormalLanguage "Formal Language"@en) SubClassOf(SOMA:FormalLanguage SOMA:Language) SubClassOf(SOMA:FormalLanguage ObjectAllValuesFrom(SOMA:givesMeaningTo SOMA:Structured_Text)) -# Class: (Graph database) +# Class: SOMA:GraphDatabase (Graph database) AnnotationAssertion(rdfs:comment SOMA:GraphDatabase "A Graph Database is a Database that uses graph structures for semantic queries with nodes, edges, and properties to represent and store data."@en) AnnotationAssertion(rdfs:label SOMA:GraphDatabase "Graph database"@en) SubClassOf(SOMA:GraphDatabase SOMA:Database) -# Class: (Graph query language) +# Class: SOMA:GraphQueryLanguage (Graph query language) AnnotationAssertion(rdfs:comment SOMA:GraphQueryLanguage "A Query Language that is designed for communication with some Graph Database."@en) AnnotationAssertion(rdfs:label SOMA:GraphQueryLanguage "Graph query language"@en) SubClassOf(SOMA:GraphQueryLanguage SOMA:QueryLanguage) -# Class: (Host role) +# Class: SOMA:HostRole (Host role) AnnotationAssertion(rdfs:comment SOMA:HostRole "In the Plug-in-Host pattern, a Host application provides services which the Plug-in can use, including a way for Plug-ins to register themselves with the Host application and a protocol for the exchange of data withPplug-ins. Plug-ins depend on the services provided by the host application and do not usually work by themselves. Conversely, the host application operates independently of the plug-ins, making it possible for end-users to add and update plug-ins dynamically without needing to make changes to the host application. @@ -334,26 +332,26 @@ AnnotationAssertion(rdfs:label SOMA:HostRole "Host role"@en) SubClassOf(SOMA:HostRole SOMA:InterfaceComponentRole) SubClassOf(SOMA:HostRole ObjectSomeValuesFrom( SOMA:PluginSpecification)) -# Class: (Human-readable Programming Language) +# Class: SOMA:Human-readable_Programming_Language (Human-readable Programming Language) AnnotationAssertion(rdfs:comment SOMA:Human-readable_Programming_Language "A Programming language like Java, Python etc. but not binary machine code."@en) AnnotationAssertion(rdfs:label SOMA:Human-readable_Programming_Language "Human-readable Programming Language"@en) SubClassOf(SOMA:Human-readable_Programming_Language SOMA:Programming_Language) SubClassOf(SOMA:Human-readable_Programming_Language ObjectAllValuesFrom(SOMA:givesMeaningTo SOMA:Source_Code)) -# Class: (Incompatible software) +# Class: SOMA:IncompatibleSoftware (Incompatible software) AnnotationAssertion(rdfs:comment SOMA:IncompatibleSoftware "A description of a situation where two software systems are incompatible with each other.") AnnotationAssertion(rdfs:label SOMA:IncompatibleSoftware "Incompatible software"@en) SubClassOf(SOMA:IncompatibleSoftware SOMA:SoftwareDiagnosis) -# Class: (Interface component role) +# Class: SOMA:InterfaceComponentRole (Interface component role) AnnotationAssertion(rdfs:label SOMA:InterfaceComponentRole "Interface component role"@en) EquivalentClasses(SOMA:InterfaceComponentRole ObjectIntersectionOf(SOMA:SoftwareRole ObjectAllValuesFrom( SOMA:InterfaceSpecification))) SubClassOf(SOMA:InterfaceComponentRole SOMA:SoftwareRole) -# Class: (Interface Specification) +# Class: SOMA:InterfaceSpecification (Interface Specification) AnnotationAssertion(rdfs:comment SOMA:InterfaceSpecification "The Specification of an Interface between software, computer hardware, peripheral devices, humans and combinations of these. @@ -361,13 +359,13 @@ Source: https://en.wikipedia.org/wiki/Interface_(computing)"@en) AnnotationAssertion(rdfs:label SOMA:InterfaceSpecification "Interface Specification"@en) SubClassOf(SOMA:InterfaceSpecification ) -# Class: (Knowledge Representation Language) +# Class: SOMA:KnowledgeRepresentationLanguage (Knowledge Representation Language) AnnotationAssertion(rdfs:comment SOMA:KnowledgeRepresentationLanguage "A Knowledge Representation Language is a Language with fixed semantics and syntax to describe some knowledge. Examples are JSON and the different OWL Profiles."@en) AnnotationAssertion(rdfs:label SOMA:KnowledgeRepresentationLanguage "Knowledge Representation Language"@en) SubClassOf(SOMA:KnowledgeRepresentationLanguage SOMA:Computer_Language) -# Class: (Language) +# Class: SOMA:Language (Language) AnnotationAssertion(rdfs:comment SOMA:Language "A Language is a structured System for communication. @@ -376,7 +374,7 @@ AnnotationAssertion(rdfs:label SOMA:Language "Language"@en) SubClassOf(SOMA:Language SOMA:System) SubClassOf(SOMA:Language ObjectAllValuesFrom(SOMA:givesMeaningTo SOMA:Text)) -# Class: (Markup Language) +# Class: SOMA:Markup_Language (Markup Language) AnnotationAssertion(rdfs:comment SOMA:Markup_Language "Markup refers to data included in an electronic document which is distinct from the document's content in that it is typically not included in representations of the document for end users, for example on paper or a computer screen, or in an audio stream. Markup is often used to control the display of the document or to enrich its content to facilitate automated processing. A markup language is a set of rules governing what markup information may be included in a document and how it is combined with the content of the document in a way to facilitate use by humans and computer programs. @@ -384,7 +382,7 @@ From Wikipedia: https://en.wikipedia.org/wiki/Markup_language"@en) AnnotationAssertion(rdfs:label SOMA:Markup_Language "Markup Language"@en) SubClassOf(SOMA:Markup_Language SOMA:Computer_Language) -# Class: (Natural Language) +# Class: SOMA:Natural_Language (Natural Language) AnnotationAssertion(rdfs:comment SOMA:Natural_Language "A Natural Language is any language that has evolved naturally in humans through use and repetition without conscious planning or premeditation. @@ -393,13 +391,13 @@ AnnotationAssertion(rdfs:label SOMA:Natural_Language "Natural Language"@en) SubClassOf(SOMA:Natural_Language SOMA:Language) SubClassOf(SOMA:Natural_Language ObjectAllValuesFrom(SOMA:givesMeaningTo SOMA:Natural_Language_Text)) -# Class: (Natural language text) +# Class: SOMA:Natural_Language_Text (Natural language text) AnnotationAssertion(rdfs:comment SOMA:Natural_Language_Text "A Text in a Natural Language."@en) AnnotationAssertion(rdfs:label SOMA:Natural_Language_Text "Natural language text"@en) EquivalentClasses(SOMA:Natural_Language_Text ObjectIntersectionOf(SOMA:Text ObjectSomeValuesFrom(SOMA:isGivenMeaningBy SOMA:Natural_Language))) -# Class: () +# Class: SOMA:Ontology (SOMA:Ontology) AnnotationAssertion(rdfs:comment SOMA:Ontology "An ontology encompasses a representation, formal naming, and definition of the categories, properties, and relations between the concepts, data, and entities that substantiate one, many, or all domains of discourse. More simply, an ontology is a way of showing the properties of a subject area and how they are related, by defining a set of concepts and categories that represent the subject. @@ -407,7 +405,7 @@ From Wikipedia: https://en.wikipedia.org/wiki/Ontology_(information_science)"@en EquivalentClasses(SOMA:Ontology ObjectIntersectionOf(SOMA:Structured_Text ObjectSomeValuesFrom(SOMA:isGivenMeaningBy SOMA:Ontology_Language))) SubClassOf(SOMA:Ontology SOMA:Structured_Text) -# Class: (Ontology Language) +# Class: SOMA:Ontology_Language (Ontology Language) AnnotationAssertion(rdfs:comment SOMA:Ontology_Language "An Ontology Language is a Knowledge Representation Language to describe knowledge about properties of a subject area and how they are related, by defining a set of concepts and categories that represent the subject using logic. Examples are the different OWL Profiles. @@ -416,7 +414,7 @@ AnnotationAssertion(rdfs:label SOMA:Ontology_Language "Ontology Language"@en) SubClassOf(SOMA:Ontology_Language SOMA:KnowledgeRepresentationLanguage) SubClassOf(SOMA:Ontology_Language ObjectAllValuesFrom(SOMA:givesMeaningTo SOMA:Ontology)) -# Class: (Plugin role) +# Class: SOMA:PluginRole (Plugin role) AnnotationAssertion(rdfs:comment SOMA:PluginRole "In the Plug-in-Host pattern, a Host application provides services which the Plug-in can use, including a way for Plug-ins to register themselves with the Host application and a protocol for the exchange of data withPplug-ins. Plug-ins depend on the services provided by the host application and do not usually work by themselves. Conversely, the host application operates independently of the plug-ins, making it possible for end-users to add and update plug-ins dynamically without needing to make changes to the host application. @@ -425,27 +423,27 @@ AnnotationAssertion(rdfs:label SOMA:PluginRole "Plugin role"@en) SubClassOf(SOMA:PluginRole SOMA:InterfaceComponentRole) SubClassOf(SOMA:PluginRole ObjectSomeValuesFrom( SOMA:PluginSpecification)) -# Class: (Plugin Specification) +# Class: SOMA:PluginSpecification (Plugin Specification) AnnotationAssertion(rdfs:comment SOMA:PluginSpecification "The Specification of a Plugin interface defines how a Host and a Plug-in function together and exchange information."@en) AnnotationAssertion(rdfs:label SOMA:PluginSpecification "Plugin Specification"@en) SubClassOf(SOMA:PluginSpecification SOMA:API_Specification) SubClassOf(SOMA:PluginSpecification ObjectIntersectionOf(ObjectSomeValuesFrom( SOMA:HostRole) ObjectSomeValuesFrom( SOMA:PluginRole))) -# Class: (Programming language) +# Class: SOMA:Programming_Language (Programming language) AnnotationAssertion(rdfs:comment SOMA:Programming_Language "Any Programming Language, including both human-readable like Java and non-human-readable languages like binary machine code."@en) AnnotationAssertion(rdfs:label SOMA:Programming_Language "Programming language"@en) SubClassOf(SOMA:Programming_Language SOMA:Computer_Language) SubClassOf(SOMA:Programming_Language ObjectAllValuesFrom(SOMA:givesMeaningTo SOMA:Computer_Program)) -# Class: (Query engine) +# Class: SOMA:QueryEngine (Query engine) AnnotationAssertion(rdfs:comment SOMA:QueryEngine "A Query Engine is a Software that can answer some queries."@en) AnnotationAssertion(rdfs:label SOMA:QueryEngine "Query engine"@en) SubClassOf(SOMA:QueryEngine SOMA:SoftwareRole) -# Class: (Query language) +# Class: SOMA:QueryLanguage (Query language) AnnotationAssertion(rdfs:comment SOMA:QueryLanguage "Query languages, are Computer languages used to make queries in databases and information systems (Source: https://en.wikipedia.org/wiki/Query_language). @@ -453,7 +451,7 @@ Note that despite their name, Query languages typically come with syntax and sem AnnotationAssertion(rdfs:label SOMA:QueryLanguage "Query language"@en) SubClassOf(SOMA:QueryLanguage SOMA:Computer_Language) -# Class: () +# Class: SOMA:Reasoner (SOMA:Reasoner) AnnotationAssertion(rdfs:comment SOMA:Reasoner "A Reasoner is some Software that can infer new, implicit knowlegde from explicitly stated knowledge. @@ -463,7 +461,7 @@ This definition is broad and we consider any System fitting the above descriptio * A logic based rule engine, where initial facts are the explicit knowledge, and derived facts are the implicit knowledge."@en) SubClassOf(SOMA:Reasoner SOMA:SoftwareRole) -# Class: (Relational database) +# Class: SOMA:RelationalDatabase (Relational database) AnnotationAssertion(rdfs:comment SOMA:RelationalDatabase "A Relational Database is a Database based on the relational model of data, which organizes data into one or more tables (or \"relations\") of columns and rows, with a unique key identifying each row. @@ -471,13 +469,13 @@ Source: https://en.wikipedia.org/wiki/Relational_database"@en) AnnotationAssertion(rdfs:label SOMA:RelationalDatabase "Relational database"@en) SubClassOf(SOMA:RelationalDatabase SOMA:Database) -# Class: (Relational query language) +# Class: SOMA:RelationalQueryLanguage (Relational query language) AnnotationAssertion(rdfs:comment SOMA:RelationalQueryLanguage "A Query Language that is designed for communication with some Relational Database."@en) AnnotationAssertion(rdfs:label SOMA:RelationalQueryLanguage "Relational query language"@en) SubClassOf(SOMA:RelationalQueryLanguage SOMA:QueryLanguage) -# Class: (Server role) +# Class: SOMA:ServerRole (Server role) AnnotationAssertion(rdfs:comment SOMA:ServerRole "The Client-server model is a distributed application structure that partitions tasks or workloads between the providers of a resource or service, called servers, and service requesters, called clients Often clients and servers communicate over a computer network on separate hardware, but both client and server may reside in the same system. A server host runs one or more server programs, which share their resources with clients. A client usually does not share any of its resources, but it requests content or service from a server. Clients, therefore, initiate communication sessions with servers, which await incoming requests. Examples of computer applications that use the client-server model are email, network printing, and the World Wide Web. @@ -486,13 +484,13 @@ AnnotationAssertion(rdfs:label SOMA:ServerRole "Server role"@en) SubClassOf(SOMA:ServerRole SOMA:InterfaceComponentRole) SubClassOf(SOMA:ServerRole ObjectSomeValuesFrom( SOMA:Client-Server_Specification)) -# Class: (A Simulation-based Reasoner is a simulation that is used as a reasoner, where the explicit knowledge corresponds to the initial situation, and the implicit knowlegde corresponds to the situation that is derived from that by simulating some unfolding processes.) +# Class: SOMA:Simulation_Reasoner (Simulation-based reasoner) -AnnotationAssertion(rdfs:label SOMA:Simulation_Reasoner "A Simulation-based Reasoner is a simulation that is used as a reasoner, where the explicit knowledge corresponds to the initial situation, and the implicit knowlegde corresponds to the situation that is derived from that by simulating some unfolding processes."@en) +AnnotationAssertion(rdfs:comment SOMA:Simulation_Reasoner "A Simulation-based Reasoner is a simulation that is used as a reasoner, where the explicit knowledge corresponds to the initial situation, and the implicit knowlegde corresponds to the situation that is derived from that by simulating some unfolding processes."@en) AnnotationAssertion(rdfs:label SOMA:Simulation_Reasoner "Simulation-based reasoner"@en) SubClassOf(SOMA:Simulation_Reasoner SOMA:Reasoner) -# Class: (Software) +# Class: SOMA:Software (Software) AnnotationAssertion(rdfs:label SOMA:Software "Software"@en) AnnotationAssertion(rdfs:label SOMA:Software "We see Software as the Design of a DesignedTool: the running instance of said Software. Software as a design also follows the Function-Behaviour-Structure model: @@ -503,30 +501,32 @@ The Behaviour are the algoirthms used by the Software Instance, e.g., Bubble Sor The Structure is the organization of files, classes, objects and method calls of the program code."@en) SubClassOf(SOMA:Software ) +SubClassOf(SOMA:Software ObjectSomeValuesFrom( SOMA:Software_Configuration)) +SubClassOf(SOMA:Software ObjectAllValuesFrom( ObjectUnionOf(SOMA:SoftwareInstance SOMA:Software_Configuration))) -# Class: (Software instance) +# Class: SOMA:SoftwareInstance (Software instance) AnnotationAssertion(rdfs:comment SOMA:SoftwareInstance "A Software instance is an entity to represent the agent that emerges from and while executing software: Some object, that can perform actions and communicate via some interfaces. In this view, we see the of an Agent required intentionality its intentionality as bestowed upon the Software instance from the agents who started the program or gave an input (e.g., via a mouse click) to achieve some goal. Another apporach might be to not model this entity at all and only see Execution of Software as a Process (see, e.g., https://en.wikipedia.org/wiki/Execution_(computing)). However, this would complicate modeling communication between running Software processes."@en) AnnotationAssertion(rdfs:label SOMA:SoftwareInstance "Software instance"@en) -SubClassOf(SOMA:SoftwareInstance ObjectIntersectionOf(SOMA:DesignedTool ObjectSomeValuesFrom(SOMA:isDesignedBy SOMA:Software))) SubClassOf(SOMA:SoftwareInstance ObjectIntersectionOf( ObjectSomeValuesFrom( ))) +SubClassOf(SOMA:SoftwareInstance ObjectSomeValuesFrom(SOMA:isDesignedBy SOMA:Software)) -# Class: (Software Library) +# Class: SOMA:SoftwareLibrary (Software Library) AnnotationAssertion(rdfs:label SOMA:SoftwareLibrary "Software Library"@en) SubClassOf(SOMA:SoftwareLibrary SOMA:Software) -# Class: (Software role) +# Class: SOMA:SoftwareRole (Software role) AnnotationAssertion(rdfs:comment SOMA:SoftwareRole "A Software Role is a Role applying to only Software and encoding the purpose of the Software: Its Role within Interface Patterns (e.g. Client vs. Server), its functionality (e.g. Database vs. Comnputer Game), and so on."@en) AnnotationAssertion(rdfs:label SOMA:SoftwareRole "Software role"@en) SubClassOf(SOMA:SoftwareRole ) SubClassOf(SOMA:SoftwareRole ObjectAllValuesFrom( SOMA:Software)) -# Class: (Software Configuration) +# Class: SOMA:Software_Configuration (Software Configuration) AnnotationAssertion(rdfs:label SOMA:Software_Configuration "Software Configuration"@en) AnnotationAssertion(rdfs:label SOMA:Software_Configuration "The part-whole relationship of Software and its components. Every Software has (at least 1) such configuration that exactly describes all Resources that make up the software (i.e., that are needed for the Software to function). @@ -535,27 +535,34 @@ We support seperate views: 2. It describes a Software Suit, e.g., 'Open Office' consists of Writer, Calc, Impress etc. Note that thus. Software can consist of other Software - this pattern may also be useful when describing Software Components, e.g., that some Software relies on a Database Software. 3. It describes not the files, but their content (the program code), which can also be seen as the part-whole relationship if one abstracts away from the files."@en) SubClassOf(SOMA:Software_Configuration ) +SubClassOf(SOMA:Software_Configuration ObjectExactCardinality(1 SOMA:Software)) -# Class: (Source code) +# Class: SOMA:Source_Code (Source code) AnnotationAssertion(rdfs:comment SOMA:Source_Code "The Source Code itself (the specific set of instruction in a human-readable Programming Language), not the file that it is contained in nor the implemented algorithm!"@en) AnnotationAssertion(rdfs:label SOMA:Source_Code "Source code"@en) EquivalentClasses(SOMA:Source_Code ObjectIntersectionOf(SOMA:Computer_Program ObjectSomeValuesFrom(SOMA:isGivenMeaningBy SOMA:Human-readable_Programming_Language))) SubClassOf(SOMA:Source_Code SOMA:Computer_Program) -# Class: (A Statistical Reasoner is a Reasoner that uses statistical or stochastical data to infer implicit information from explicit information. Examples are Hidden Markov Models and Neural Networks.) +# Class: SOMA:StatisticalReasoner (Statistical reasoner) AnnotationAssertion(rdfs:label SOMA:StatisticalReasoner "A Statistical Reasoner is a Reasoner that uses statistical or stochastical data to infer implicit information from explicit information. Examples are Hidden Markov Models and Neural Networks."@en) AnnotationAssertion(rdfs:label SOMA:StatisticalReasoner "Statistical reasoner"@en) SubClassOf(SOMA:StatisticalReasoner SOMA:Reasoner) -# Class: (Structured text) +# Class: SOMA:Structured_Text (Structured text) AnnotationAssertion(rdfs:comment SOMA:Structured_Text "Any Text that adheres to some rules that are in any way more specific than natural language and that cannot be made sense of without knowing said rules."@en) AnnotationAssertion(rdfs:label SOMA:Structured_Text "Structured text"@en) EquivalentClasses(SOMA:Structured_Text ObjectIntersectionOf(SOMA:Text ObjectSomeValuesFrom(SOMA:isGivenMeaningBy SOMA:FormalLanguage))) -# Class: (Symbolic reasoner) +# Class: SOMA:SubCognitiveAgent (Sub-cognitive agent) + +AnnotationAssertion(rdfs:comment SOMA:SubCognitiveAgent "An agent that is not capable to act on its own, i.e., that is reactive. Its intentionality needs to be bestowed upon from some other agent, that it acts for."@en) +AnnotationAssertion(rdfs:label SOMA:SubCognitiveAgent "Sub-cognitive agent"@en) +SubClassOf(SOMA:SubCognitiveAgent ) + +# Class: SOMA:SymbolicReasoner (Symbolic reasoner) AnnotationAssertion(rdfs:comment SOMA:SymbolicReasoner "A Symbolic Reasoner, is a piece of software able to infer logical consequences from a set of asserted facts or axioms. @@ -563,7 +570,7 @@ Source: https://en.wikipedia.org/wiki/Semantic_reasoner"@en) AnnotationAssertion(rdfs:label SOMA:SymbolicReasoner "Symbolic reasoner"@en) SubClassOf(SOMA:SymbolicReasoner SOMA:Reasoner) -# Class: (System) +# Class: SOMA:System (System) AnnotationAssertion(rdfs:comment SOMA:System "A system is a group of interacting or interrelated elements that act according to a set of rules to form a unified whole. @@ -571,7 +578,7 @@ From Wikipedia: https://en.wikipedia.org/wiki/System"@en) AnnotationAssertion(rdfs:label SOMA:System "System"@en) SubClassOf(SOMA:System ) -# Class: (Text) +# Class: SOMA:Text (Text) AnnotationAssertion(rdfs:comment SOMA:Text "Any Information Object defined using a Language that, when realized through a symbolic writing system, can be read and made sense of. @@ -582,13 +589,13 @@ On the other hand, this might not be true as both could be encoded in a binary f AnnotationAssertion(rdfs:label SOMA:Text "Text"@en) EquivalentClasses(SOMA:Text ObjectIntersectionOf( ObjectSomeValuesFrom(SOMA:isGivenMeaningBy SOMA:Language))) -# Class: (Triplestore) +# Class: SOMA:Triplestore (Triplestore) AnnotationAssertion(rdfs:comment SOMA:Triplestore "A Triplestore or RDF store is a purpose-built database for the storage and retrieval of triples through semantic queries."@en) AnnotationAssertion(rdfs:label SOMA:Triplestore "Triplestore"@en) SubClassOf(SOMA:Triplestore SOMA:GraphDatabase) -# Class: (Unavailable software) +# Class: SOMA:UnavailableSoftware (Unavailable software) AnnotationAssertion(rdfs:comment SOMA:UnavailableSoftware "A description of a situation where some software dependency is not available.") AnnotationAssertion(rdfs:label SOMA:UnavailableSoftware "Unavailable software"@en) diff --git a/owl/SOMA-NEEM.owl b/owl/SOMA-NEEM.owl index 7f6c8846..860e506d 100644 --- a/owl/SOMA-NEEM.owl +++ b/owl/SOMA-NEEM.owl @@ -22,21 +22,21 @@ Declaration(Class(SOMA:VideoData)) # Classes ############################ -# Class: (Kino-dynamic data) +# Class: SOMA:KinoDynamicData (Kino-dynamic data) AnnotationAssertion(rdfs:comment SOMA:KinoDynamicData "An InformationObject containing data about how a physical object is put together such that its parts may move relative to each other, and what the physical characteristics of those parts are.") AnnotationAssertion(rdfs:label SOMA:KinoDynamicData "Kino-dynamic data"@en) SubClassOf(SOMA:KinoDynamicData ) SubClassOf(SOMA:KinoDynamicData ObjectAllValuesFrom( )) -# Class: (Mesh-shape data) +# Class: SOMA:MeshShapeData (Mesh-shape data) AnnotationAssertion(rdfs:comment SOMA:MeshShapeData "An InformationObject containing data about the geometry of a physical object.") AnnotationAssertion(rdfs:label SOMA:MeshShapeData "Mesh-shape data"@en) SubClassOf(SOMA:MeshShapeData ) SubClassOf(SOMA:MeshShapeData ObjectAllValuesFrom( )) -# Class: (Video data) +# Class: SOMA:VideoData (Video data) AnnotationAssertion(rdfs:comment SOMA:VideoData "An information object containing data for audio-visual modalities.") AnnotationAssertion(rdfs:label SOMA:VideoData "Video data"@en) diff --git a/owl/SOMA-OBJ.owl b/owl/SOMA-OBJ.owl index d85a5843..ec711733 100644 --- a/owl/SOMA-OBJ.owl +++ b/owl/SOMA-OBJ.owl @@ -58,7 +58,6 @@ Declaration(Class(:StoredObject)) Declaration(Class(SOMA:Accessor)) Declaration(Class(SOMA:AestheticDesign)) Declaration(Class(SOMA:Affordance)) -Declaration(Class(SOMA:AgentRole)) Declaration(Class(SOMA:AlteredObject)) Declaration(Class(SOMA:Appliance)) Declaration(Class(SOMA:Arm)) @@ -109,6 +108,7 @@ Declaration(Class(SOMA:Effort)) Declaration(Class(SOMA:EnclosedObject)) Declaration(Class(SOMA:Enclosing)) Declaration(Class(SOMA:EventAdjacentRole)) +Declaration(Class(SOMA:ExcludedObject)) Declaration(Class(SOMA:ExistingObjectRole)) Declaration(Class(SOMA:ExperiencerRole)) Declaration(Class(SOMA:ExtractedObject)) @@ -148,6 +148,7 @@ Declaration(Class(SOMA:Obstacle)) Declaration(Class(SOMA:Origin)) Declaration(Class(SOMA:PathRole)) Declaration(Class(SOMA:Patient)) +Declaration(Class(SOMA:PerformerRole)) Declaration(Class(SOMA:PhysicalEffector)) Declaration(Class(SOMA:PhysicalQuality)) Declaration(Class(SOMA:PrehensileEffector)) @@ -159,6 +160,7 @@ Declaration(Class(SOMA:RedColor)) Declaration(Class(SOMA:RelationAdjacentRole)) Declaration(Class(SOMA:RelatumRole)) Declaration(Class(SOMA:RelevantPart)) +Declaration(Class(SOMA:RemovedObject)) Declaration(Class(SOMA:ResourceRole)) Declaration(Class(SOMA:RestrictedObject)) Declaration(Class(SOMA:Restrictor)) @@ -216,18 +218,20 @@ Declaration(ObjectProperty(SOMA:affordanceDefines)) Declaration(ObjectProperty(SOMA:affordanceDefinesTask)) Declaration(ObjectProperty(SOMA:affordsBearer)) Declaration(ObjectProperty(SOMA:affordsConcept)) +Declaration(ObjectProperty(SOMA:affordsPerformer)) Declaration(ObjectProperty(SOMA:affordsSetpoint)) Declaration(ObjectProperty(SOMA:affordsTask)) Declaration(ObjectProperty(SOMA:affordsTrigger)) Declaration(ObjectProperty(SOMA:containsObject)) Declaration(ObjectProperty(SOMA:definesBearer)) +Declaration(ObjectProperty(SOMA:definesEventType)) Declaration(ObjectProperty(SOMA:definesParameter)) +Declaration(ObjectProperty(SOMA:definesPerformer)) Declaration(ObjectProperty(SOMA:definesSetpoint)) Declaration(ObjectProperty(SOMA:definesTrigger)) Declaration(ObjectProperty(SOMA:describesQuality)) Declaration(ObjectProperty(SOMA:hasAlterationResult)) Declaration(ObjectProperty(SOMA:hasColor)) -Declaration(ObjectProperty(SOMA:hasDesign)) Declaration(ObjectProperty(SOMA:hasDisposition)) Declaration(ObjectProperty(SOMA:hasFeature)) Declaration(ObjectProperty(SOMA:hasFrictionAttribute)) @@ -246,15 +250,17 @@ Declaration(ObjectProperty(SOMA:isColorOf)) Declaration(ObjectProperty(SOMA:isConceptAffordedBy)) Declaration(ObjectProperty(SOMA:isDefinedInAffordance)) Declaration(ObjectProperty(SOMA:isDepositOf)) -Declaration(ObjectProperty(SOMA:isDesignOf)) Declaration(ObjectProperty(SOMA:isDispositionOf)) Declaration(ObjectProperty(SOMA:isEffectorInvolvedIn)) +Declaration(ObjectProperty(SOMA:isExecutorDefinedIn)) Declaration(ObjectProperty(SOMA:isFeatureOf)) Declaration(ObjectProperty(SOMA:isInsideOf)) Declaration(ObjectProperty(SOMA:isLinkedTo)) Declaration(ObjectProperty(SOMA:isLocalizationOf)) Declaration(ObjectProperty(SOMA:isOntopOf)) Declaration(ObjectProperty(SOMA:isParameterDefinedIn)) +Declaration(ObjectProperty(SOMA:isPerformerAffordedBy)) +Declaration(ObjectProperty(SOMA:isPerformerDefinedIn)) Declaration(ObjectProperty(SOMA:isPhysicallyContainedIn)) Declaration(ObjectProperty(SOMA:isQualeOf)) Declaration(ObjectProperty(SOMA:isQualityDescribedBy)) @@ -306,8 +312,8 @@ Declaration(DataProperty(SOMA:hasWidth)) # Object Property: :hasChildLink (has child link) -AnnotationAssertion(rdfs:comment :hasChildLink "Relates a joint to the link it connects which is closer to the end of the kinematic chain.") -AnnotationAssertion(rdfs:label :hasChildLink "has child link") +AnnotationAssertion(rdfs:comment :hasChildLink "Relates a joint to the link it connects which is closer to the end of the kinematic chain."^^xsd:string) +AnnotationAssertion(rdfs:label :hasChildLink "has child link"^^xsd:string) SubObjectPropertyOf(:hasChildLink ) InverseObjectProperties(:hasChildLink :isChildLinkOf) ObjectPropertyDomain(:hasChildLink :Joint) @@ -315,8 +321,8 @@ ObjectPropertyRange(:hasChildLink ) @@ -324,8 +330,8 @@ ObjectPropertyRange(:hasEndLink ) InverseObjectProperties(:hasJointLimit :isJointLimitOf) ObjectPropertyDomain(:hasJointLimit :Joint) @@ -333,8 +339,8 @@ ObjectPropertyRange(:hasJointLimit :JointLimit) # Object Property: :hasJointState (has joint state) -AnnotationAssertion(rdfs:comment :hasJointState "Relates a joint to its state.") -AnnotationAssertion(rdfs:label :hasJointState "has joint state") +AnnotationAssertion(rdfs:comment :hasJointState "Relates a joint to its state."^^xsd:string) +AnnotationAssertion(rdfs:label :hasJointState "has joint state"^^xsd:string) SubObjectPropertyOf(:hasJointState ) InverseObjectProperties(:hasJointState :isJointStateOf) ObjectPropertyDomain(:hasJointState :Joint) @@ -342,8 +348,8 @@ ObjectPropertyRange(:hasJointState :JointState) # Object Property: :hasLink (has link) -AnnotationAssertion(rdfs:comment :hasLink "Relates an object to its kinematic components.") -AnnotationAssertion(rdfs:label :hasLink "has link") +AnnotationAssertion(rdfs:comment :hasLink "Relates an object to its kinematic components."^^xsd:string) +AnnotationAssertion(rdfs:label :hasLink "has link"^^xsd:string) SubObjectPropertyOf(:hasLink ) InverseObjectProperties(:hasLink :isLinkOf) ObjectPropertyDomain(:hasLink ) @@ -351,8 +357,8 @@ ObjectPropertyRange(:hasLink ) InverseObjectProperties(:hasNetForce :isNetForceOf) ObjectPropertyDomain(:hasNetForce ) @@ -360,8 +366,8 @@ ObjectPropertyRange(:hasNetForce :NetForce) # Object Property: :hasParentLink (has parent link) -AnnotationAssertion(rdfs:comment :hasParentLink "Relates a joint to the link it connects which is closer to the root of the kinematic chain.") -AnnotationAssertion(rdfs:label :hasParentLink "has parent link") +AnnotationAssertion(rdfs:comment :hasParentLink "Relates a joint to the link it connects which is closer to the root of the kinematic chain."^^xsd:string) +AnnotationAssertion(rdfs:label :hasParentLink "has parent link"^^xsd:string) SubObjectPropertyOf(:hasParentLink ) InverseObjectProperties(:hasParentLink :isParentLinkOf) ObjectPropertyDomain(:hasParentLink :Joint) @@ -369,8 +375,8 @@ ObjectPropertyRange(:hasParentLink ) @@ -378,48 +384,48 @@ ObjectPropertyRange(:hasRootLink ) ObjectPropertyDomain(:isChildLinkOf ) ObjectPropertyRange(:isChildLinkOf :Joint) # Object Property: :isEndLinkOf (is end link of) -AnnotationAssertion(rdfs:comment :isEndLinkOf "Relates an object to kinematic components at the end of the kinematic chain.") -AnnotationAssertion(rdfs:label :isEndLinkOf "is end link of") +AnnotationAssertion(rdfs:comment :isEndLinkOf "Relates an object to kinematic components at the end of the kinematic chain."^^xsd:string) +AnnotationAssertion(rdfs:label :isEndLinkOf "is end link of"^^xsd:string) SubObjectPropertyOf(:isEndLinkOf :isLinkOf) ObjectPropertyDomain(:isEndLinkOf ) ObjectPropertyRange(:isEndLinkOf ) # Object Property: :isJointLimitOf (is joint limit of) -AnnotationAssertion(rdfs:comment :isJointLimitOf "Relates a joint to its physical limits.") -AnnotationAssertion(rdfs:label :isJointLimitOf "is joint limit of") +AnnotationAssertion(rdfs:comment :isJointLimitOf "Relates a joint to its physical limits."^^xsd:string) +AnnotationAssertion(rdfs:label :isJointLimitOf "is joint limit of"^^xsd:string) SubObjectPropertyOf(:isJointLimitOf ) ObjectPropertyDomain(:isJointLimitOf :JointLimit) ObjectPropertyRange(:isJointLimitOf :Joint) # Object Property: :isJointStateOf (is joint state of) -AnnotationAssertion(rdfs:comment :isJointStateOf "Relates a joint to its state.") -AnnotationAssertion(rdfs:label :isJointStateOf "is joint state of") +AnnotationAssertion(rdfs:comment :isJointStateOf "Relates a joint to its state."^^xsd:string) +AnnotationAssertion(rdfs:label :isJointStateOf "is joint state of"^^xsd:string) SubObjectPropertyOf(:isJointStateOf ) ObjectPropertyDomain(:isJointStateOf :JointState) ObjectPropertyRange(:isJointStateOf :Joint) # Object Property: :isLinkOf (is link of) -AnnotationAssertion(rdfs:comment :isLinkOf "Relates an object to its kinematic components.") -AnnotationAssertion(rdfs:label :isLinkOf "is link of") +AnnotationAssertion(rdfs:comment :isLinkOf "Relates an object to its kinematic components."^^xsd:string) +AnnotationAssertion(rdfs:label :isLinkOf "is link of"^^xsd:string) SubObjectPropertyOf(:isLinkOf ) ObjectPropertyDomain(:isLinkOf ) ObjectPropertyRange(:isLinkOf ) # Object Property: :isMassAttributeOf (is mass attribute of) -AnnotationAssertion(rdfs:comment :isMassAttributeOf "A relation between physical objects and their mass.") -AnnotationAssertion(rdfs:label :isMassAttributeOf "is mass attribute of") +AnnotationAssertion(rdfs:comment :isMassAttributeOf "A relation between physical objects and their mass."^^xsd:string) +AnnotationAssertion(rdfs:label :isMassAttributeOf "is mass attribute of"^^xsd:string) SubObjectPropertyOf(:isMassAttributeOf ) InverseObjectProperties(:isMassAttributeOf SOMA:hasMassAttribute) ObjectPropertyDomain(:isMassAttributeOf SOMA:MassAttribute) @@ -427,24 +433,24 @@ ObjectPropertyRange(:isMassAttributeOf ) ObjectPropertyDomain(:isNetForceOf :NetForce) ObjectPropertyRange(:isNetForceOf ) # Object Property: :isParentLinkOf (is parent link of) -AnnotationAssertion(rdfs:comment :isParentLinkOf "Relates a joint to the link it connects which is closer to the root of the kinematic chain.") -AnnotationAssertion(rdfs:label :isParentLinkOf "is parent link of") +AnnotationAssertion(rdfs:comment :isParentLinkOf "Relates a joint to the link it connects which is closer to the root of the kinematic chain."^^xsd:string) +AnnotationAssertion(rdfs:label :isParentLinkOf "is parent link of"^^xsd:string) SubObjectPropertyOf(:isParentLinkOf ) ObjectPropertyDomain(:isParentLinkOf ) ObjectPropertyRange(:isParentLinkOf :Joint) # Object Property: :isRootLinkOf (is root link of) -AnnotationAssertion(rdfs:comment :isRootLinkOf "Relates an object to kinematic components at the root of the kinematic chain.") -AnnotationAssertion(rdfs:label :isRootLinkOf "is root link of") +AnnotationAssertion(rdfs:comment :isRootLinkOf "Relates an object to kinematic components at the root of the kinematic chain."^^xsd:string) +AnnotationAssertion(rdfs:label :isRootLinkOf "is root link of"^^xsd:string) SubObjectPropertyOf(:isRootLinkOf :isLinkOf) ObjectPropertyDomain(:isRootLinkOf ) ObjectPropertyRange(:isRootLinkOf ) @@ -486,6 +492,16 @@ InverseObjectProperties(SOMA:affordsConcept SOMA:isConceptAffordedBy) ObjectPropertyDomain(SOMA:affordsConcept SOMA:Disposition) ObjectPropertyRange(SOMA:affordsConcept ) + +# Object Property: SOMA:affordsPerformer (affords performer) + +AnnotationAssertion(rdfs:comment SOMA:affordsPerformer "Relates a disposition to the performer role defined by the affordance describing the disposition."@en) +AnnotationAssertion(rdfs:label SOMA:affordsPerformer "affords performer"@en) +SubObjectPropertyOf(SOMA:affordsPerformer SOMA:affordsConcept) +InverseObjectProperties(SOMA:affordsPerformer SOMA:isPerformerAffordedBy) +ObjectPropertyDomain(SOMA:affordsPerformer SOMA:Disposition) +ObjectPropertyRange(SOMA:affordsPerformer ) + # Object Property: SOMA:affordsSetpoint (affords setpoint) AnnotationAssertion(rdfs:comment SOMA:affordsSetpoint "Relates a disposition to the setpoint parameter defined by the affordance describing the disposition.") @@ -542,6 +558,15 @@ InverseObjectProperties(SOMA:definesParameter SOMA:isParameterDefinedIn) ObjectPropertyDomain(SOMA:definesParameter ) ObjectPropertyRange(SOMA:definesParameter ) +# Object Property: SOMA:definesPerformer (defines performer) + +AnnotationAssertion(rdfs:comment SOMA:definesPerformer "Relates an affordance which is a relation between a bearer and a trigger, to the role of the performer when the affordance is manifested."@en) +AnnotationAssertion(rdfs:label SOMA:definesPerformer "defines performer"@en) +SubObjectPropertyOf(SOMA:definesPerformer ) +InverseObjectProperties(SOMA:definesPerformer SOMA:isPerformerDefinedIn) +ObjectPropertyDomain(SOMA:definesPerformer SOMA:Affordance) +ObjectPropertyRange(SOMA:definesPerformer ) + # Object Property: SOMA:definesSetpoint (defines setpoint) AnnotationAssertion(rdfs:comment SOMA:definesSetpoint "Defines the dedicated goal region of a description.") @@ -587,15 +612,6 @@ InverseObjectProperties(SOMA:hasColor SOMA:isColorOf) ObjectPropertyDomain(SOMA:hasColor ) ObjectPropertyRange(SOMA:hasColor SOMA:Color) -# Object Property: SOMA:hasDesign (has design) - -AnnotationAssertion(rdfs:comment SOMA:hasDesign "Relates an object to the design according to which it was constructed.") -AnnotationAssertion(rdfs:label SOMA:hasDesign "has design") -SubObjectPropertyOf(SOMA:hasDesign ) -InverseObjectProperties(SOMA:hasDesign SOMA:isDesignOf) -ObjectPropertyDomain(SOMA:hasDesign ) -ObjectPropertyRange(SOMA:hasDesign ) - # Object Property: SOMA:hasDisposition (has disposition) AnnotationAssertion(rdfs:comment SOMA:hasDisposition "Associates an object to one of its dispositions.") @@ -677,7 +693,7 @@ ObjectPropertyRange(SOMA:hasSpaceRegion ) InverseObjectProperties(SOMA:involvesEffector SOMA:isEffectorInvolvedIn) @@ -741,14 +757,6 @@ InverseObjectProperties(SOMA:isDepositOf SOMA:isOntopOf) ObjectPropertyDomain(SOMA:isDepositOf ) ObjectPropertyRange(SOMA:isDepositOf ) -# Object Property: SOMA:isDesignOf (is design of) - -AnnotationAssertion(rdfs:comment SOMA:isDesignOf "Relates a design to an object that was constructed according to it.") -AnnotationAssertion(rdfs:label SOMA:isDesignOf "is design of") -SubObjectPropertyOf(SOMA:isDesignOf ) -ObjectPropertyDomain(SOMA:isDesignOf ) -ObjectPropertyRange(SOMA:isDesignOf ) - # Object Property: SOMA:isDispositionOf (is disposition of) AnnotationAssertion(rdfs:comment SOMA:isDispositionOf "Associates a disposition quality to the object holding it.") @@ -759,7 +767,7 @@ ObjectPropertyRange(SOMA:isDispositionOf ) ObjectPropertyDomain(SOMA:isEffectorInvolvedIn SOMA:PhysicalEffector) @@ -816,10 +824,27 @@ SubObjectPropertyOf(SOMA:isParameterDefinedIn ) ObjectPropertyRange(SOMA:isParameterDefinedIn ) + +# Object Property: SOMA:isPerformerAffordedBy (is performer afforded by) + +AnnotationAssertion(rdfs:label SOMA:isPerformerAffordedBy "Relates a disposition to the performer role defined by the affordance describing the disposition."@en) +AnnotationAssertion(rdfs:label SOMA:isPerformerAffordedBy "is performer afforded by"@en) +SubObjectPropertyOf(SOMA:isPerformerAffordedBy SOMA:isConceptAffordedBy) +ObjectPropertyDomain(SOMA:isPerformerAffordedBy ) +ObjectPropertyRange(SOMA:isPerformerAffordedBy SOMA:Disposition) + +# Object Property: SOMA:isPerformerDefinedIn (is performer defined in) + +AnnotationAssertion(rdfs:comment SOMA:isPerformerDefinedIn "Relates an affordance which is a relation between a bearer and a trigger, to the role of the performer when the affordance is manifested."@en) +AnnotationAssertion(rdfs:label SOMA:isPerformerDefinedIn "is performer defined in"@en) +SubObjectPropertyOf(SOMA:isPerformerDefinedIn ) +ObjectPropertyDomain(SOMA:isPerformerDefinedIn ) +ObjectPropertyRange(SOMA:isPerformerDefinedIn ) + # Object Property: SOMA:isPhysicallyContainedIn (is physically contained in) -AnnotationAssertion(rdfs:comment SOMA:isPhysicallyContainedIn "A spatial relation holding between an object (the container), and objects it contains.") -AnnotationAssertion(rdfs:label SOMA:isPhysicallyContainedIn "is physically contained in") +AnnotationAssertion(rdfs:comment SOMA:isPhysicallyContainedIn "A spatial relation holding between an object (the container), and objects it contains."^^xsd:string) +AnnotationAssertion(rdfs:label SOMA:isPhysicallyContainedIn "is physically contained in"^^xsd:string) SubObjectPropertyOf(SOMA:isPhysicallyContainedIn ) ObjectPropertyDomain(SOMA:isPhysicallyContainedIn ) ObjectPropertyRange(SOMA:isPhysicallyContainedIn ) @@ -961,72 +986,72 @@ ObjectPropertyRange(SOMA:transitionsTo ) DataPropertyDomain(:hasForceValue :ForceAttribute) DataPropertyRange(:hasForceValue SOMA:array_double) # Data Property: :hasJointEffort (has joint effort) -AnnotationAssertion(rdfs:comment :hasJointEffort "The effort applied in a joint given in N (prismatic joint) or N*m (hinged joints).") -AnnotationAssertion(rdfs:label :hasJointEffort "has joint effort") +AnnotationAssertion(rdfs:comment :hasJointEffort "The effort applied in a joint given in N (prismatic joint) or N*m (hinged joints)."^^xsd:string) +AnnotationAssertion(rdfs:label :hasJointEffort "has joint effort"^^xsd:string) SubDataPropertyOf(:hasJointEffort :hasJointParameter) DataPropertyDomain(:hasJointEffort :JointState) DataPropertyRange(:hasJointEffort xsd:double) # Data Property: :hasJointEffortLimit (has joint effort limit) -AnnotationAssertion(rdfs:comment :hasJointEffortLimit "The maximum effort applied in a joint given in N (prismatic joint) or N*m (hinged joints).") -AnnotationAssertion(rdfs:label :hasJointEffortLimit "has joint effort limit") +AnnotationAssertion(rdfs:comment :hasJointEffortLimit "The maximum effort applied in a joint given in N (prismatic joint) or N*m (hinged joints)."^^xsd:string) +AnnotationAssertion(rdfs:label :hasJointEffortLimit "has joint effort limit"^^xsd:string) SubDataPropertyOf(:hasJointEffortLimit :hasJointParameter) DataPropertyDomain(:hasJointEffortLimit :JointLimit) DataPropertyRange(:hasJointEffortLimit xsd:double) # Data Property: :hasJointParameter (has joint parameter) -AnnotationAssertion(rdfs:comment :hasJointParameter "Assigns a value for an attribute of a joint.") -AnnotationAssertion(rdfs:label :hasJointParameter "has joint parameter") +AnnotationAssertion(rdfs:comment :hasJointParameter "Assigns a value for an attribute of a joint."^^xsd:string) +AnnotationAssertion(rdfs:label :hasJointParameter "has joint parameter"^^xsd:string) SubDataPropertyOf(:hasJointParameter ) DataPropertyDomain(:hasJointParameter ) DataPropertyRange(:hasJointParameter xsd:double) # Data Property: :hasJointPosition (has joint position) -AnnotationAssertion(rdfs:comment :hasJointPosition "The position of a joint given in m (prismatic joints) or rad (hinged joints).") -AnnotationAssertion(rdfs:label :hasJointPosition "has joint position") +AnnotationAssertion(rdfs:comment :hasJointPosition "The position of a joint given in m (prismatic joints) or rad (hinged joints)."^^xsd:string) +AnnotationAssertion(rdfs:label :hasJointPosition "has joint position"^^xsd:string) SubDataPropertyOf(:hasJointPosition :hasJointParameter) DataPropertyDomain(:hasJointPosition :JointState) DataPropertyRange(:hasJointPosition xsd:double) # Data Property: :hasJointPositionMax (has joint position max) -AnnotationAssertion(rdfs:comment :hasJointPositionMax "The maximum position of a joint given in m (prismatic joints) or rad (hinged joints).") -AnnotationAssertion(rdfs:label :hasJointPositionMax "has joint position max") +AnnotationAssertion(rdfs:comment :hasJointPositionMax "The maximum position of a joint given in m (prismatic joints) or rad (hinged joints)."^^xsd:string) +AnnotationAssertion(rdfs:label :hasJointPositionMax "has joint position max"^^xsd:string) SubDataPropertyOf(:hasJointPositionMax :hasJointParameter) DataPropertyDomain(:hasJointPositionMax :JointLimit) DataPropertyRange(:hasJointPositionMax xsd:double) # Data Property: :hasJointPositionMin (has joint position min) -AnnotationAssertion(rdfs:comment :hasJointPositionMin "The minimum position of a joint given in m (prismatic joints) or rad (hinged joints).") -AnnotationAssertion(rdfs:label :hasJointPositionMin "has joint position min") +AnnotationAssertion(rdfs:comment :hasJointPositionMin "The minimum position of a joint given in m (prismatic joints) or rad (hinged joints)."^^xsd:string) +AnnotationAssertion(rdfs:label :hasJointPositionMin "has joint position min"^^xsd:string) SubDataPropertyOf(:hasJointPositionMin :hasJointParameter) DataPropertyDomain(:hasJointPositionMin :JointLimit) DataPropertyRange(:hasJointPositionMin xsd:double) # Data Property: :hasJointVelocity (has joint velocity) -AnnotationAssertion(rdfs:comment :hasJointVelocity "The velocity of a joint given in m/s (prismatic joints) or rad/s (hinged joints).") -AnnotationAssertion(rdfs:label :hasJointVelocity "has joint velocity") +AnnotationAssertion(rdfs:comment :hasJointVelocity "The velocity of a joint given in m/s (prismatic joints) or rad/s (hinged joints)."^^xsd:string) +AnnotationAssertion(rdfs:label :hasJointVelocity "has joint velocity"^^xsd:string) SubDataPropertyOf(:hasJointVelocity :hasJointParameter) DataPropertyDomain(:hasJointVelocity :JointState) DataPropertyRange(:hasJointVelocity xsd:double) # Data Property: :hasJointVelocityLimit (has joint velocity limit) -AnnotationAssertion(rdfs:comment :hasJointVelocityLimit "The maximum velocity of a joint given in m/s (prismatic joints) or rad/s (hinged joints).") -AnnotationAssertion(rdfs:label :hasJointVelocityLimit "has joint velocity limit") +AnnotationAssertion(rdfs:comment :hasJointVelocityLimit "The maximum velocity of a joint given in m/s (prismatic joints) or rad/s (hinged joints)."^^xsd:string) +AnnotationAssertion(rdfs:label :hasJointVelocityLimit "has joint velocity limit"^^xsd:string) SubDataPropertyOf(:hasJointVelocityLimit :hasJointParameter) DataPropertyDomain(:hasJointVelocityLimit :JointLimit) DataPropertyRange(:hasJointVelocityLimit xsd:double) @@ -1109,7 +1134,7 @@ DataPropertyRange(SOMA:hasMassValue xsd:double) # Data Property: SOMA:hasPositionData (has position data) AnnotationAssertion(rdfs:comment SOMA:hasPositionData "Associates a spatial region to a position.") -AnnotationAssertion(rdfs:label SOMA:hasPositionData "has position data") +AnnotationAssertion(rdfs:label SOMA:hasPositionData "has position data"^^xsd:string) SubDataPropertyOf(SOMA:hasPositionData SOMA:hasSpaceParameter) DataPropertyDomain(SOMA:hasPositionData ) DataPropertyRange(SOMA:hasPositionData xsd:string) @@ -1149,7 +1174,7 @@ DataPropertyRange(SOMA:hasShapeParameter DataUnionOf(SOMA:array_double xsd:doubl # Data Property: SOMA:hasSpaceParameter (has space parameter) AnnotationAssertion(rdfs:comment SOMA:hasSpaceParameter "Associates a SpaceRegion to some parameter value describing it. This is a fairly generic property, and to capture the semantics of the information associated to the SpaceRegion, its more specific subproperties should be used.") -AnnotationAssertion(rdfs:label SOMA:hasSpaceParameter "has space parameter") +AnnotationAssertion(rdfs:label SOMA:hasSpaceParameter "has space parameter"^^xsd:string) SubDataPropertyOf(SOMA:hasSpaceParameter ) DataPropertyDomain(SOMA:hasSpaceParameter ) @@ -1189,13 +1214,14 @@ SubClassOf(:Capability SOMA:Disposition) # Class: :ContinuousJoint (Continuous joint) -AnnotationAssertion(rdfs:comment :ContinuousJoint "A continuous hinge joint that rotates around an axis and has no upper and lower limits.") -AnnotationAssertion(rdfs:label :ContinuousJoint "Continuous joint") +AnnotationAssertion(rdfs:comment :ContinuousJoint "A continuous hinge joint that rotates around an axis and has no upper and lower limits."^^xsd:string) +AnnotationAssertion(rdfs:label :ContinuousJoint "Continuous joint"^^xsd:string) SubClassOf(:ContinuousJoint :HingeJoint) -# Class: :CutObject (:CutObject) +# Class: :CutObject (Cut object) AnnotationAssertion(rdfs:comment :CutObject "An object being cut down into pieces.") +AnnotationAssertion(rdfs:label :CutObject "Cut object") SubClassOf(:CutObject SOMA:AlteredObject) # Class: :Cuttability (:Cuttability) @@ -1212,34 +1238,34 @@ SubClassOf(:Cutter SOMA:Tool) # Class: :FixedJoint (Fixed joint) -AnnotationAssertion(rdfs:comment :FixedJoint "A joint that cannot move, designed to fixiate links.") -AnnotationAssertion(rdfs:label :FixedJoint "Fixed joint") +AnnotationAssertion(rdfs:comment :FixedJoint "A joint that cannot move, designed to fixiate links."^^xsd:string) +AnnotationAssertion(rdfs:label :FixedJoint "Fixed joint"^^xsd:string) SubClassOf(:FixedJoint :Joint) SubClassOf(:FixedJoint ObjectExactCardinality(0 :hasJointState )) DisjointClasses(:FixedJoint :MovableJoint) # Class: :FloatingJoint (Floating joint) -AnnotationAssertion(rdfs:comment :FloatingJoint "A joint that allows motion for all 6 degrees of freedom.") -AnnotationAssertion(rdfs:label :FloatingJoint "Floating joint") +AnnotationAssertion(rdfs:comment :FloatingJoint "A joint that allows motion for all 6 degrees of freedom."^^xsd:string) +AnnotationAssertion(rdfs:label :FloatingJoint "Floating joint"^^xsd:string) SubClassOf(:FloatingJoint :MovableJoint) # Class: :ForceAttribute (Force attribute) -AnnotationAssertion(rdfs:comment :ForceAttribute "The value of a force dynamical characteristic. An example is the force exerted on another object when pushing it.") -AnnotationAssertion(rdfs:label :ForceAttribute "Force attribute") +AnnotationAssertion(rdfs:comment :ForceAttribute "The value of a force dynamical characteristic. An example is the force exerted on another object when pushing it."^^xsd:string) +AnnotationAssertion(rdfs:label :ForceAttribute "Force attribute"^^xsd:string) SubClassOf(:ForceAttribute ) SubClassOf(:ForceAttribute DataExactCardinality(1 :hasForceValue SOMA:array_double)) # Class: :HingeJoint (Hinge joint) -AnnotationAssertion(rdfs:comment :HingeJoint "A joint that rotates along an axis.") -AnnotationAssertion(rdfs:label :HingeJoint "Hinge joint") +AnnotationAssertion(rdfs:comment :HingeJoint "A joint that rotates along an axis."^^xsd:string) +AnnotationAssertion(rdfs:label :HingeJoint "Hinge joint"^^xsd:string) SubClassOf(:HingeJoint :MovableJoint) # Class: :Joint (:Joint) -AnnotationAssertion(rdfs:comment :Joint "An object that is used to articulate links in a kinematic structure.") +AnnotationAssertion(rdfs:comment :Joint "An object that is used to articulate links in a kinematic structure."^^xsd:string) EquivalentClasses(:Joint ObjectUnionOf(:FixedJoint :MovableJoint)) SubClassOf(:Joint ) SubClassOf(:Joint ObjectExactCardinality(1 :hasChildLink )) @@ -1248,14 +1274,14 @@ SubClassOf(:Joint ObjectMaxCardinality(1 :hasJointState :JointState)) # Class: :JointLimit (Joint limit) -AnnotationAssertion(rdfs:comment :JointLimit "The physical limits of a joint.") -AnnotationAssertion(rdfs:label :JointLimit "Joint limit") +AnnotationAssertion(rdfs:comment :JointLimit "The physical limits of a joint."^^xsd:string) +AnnotationAssertion(rdfs:label :JointLimit "Joint limit"^^xsd:string) SubClassOf(:JointLimit ) # Class: :JointState (Joint state) -AnnotationAssertion(rdfs:comment :JointState "The state of a joint in terms of position, velocity of the joint and effort applied to it.") -AnnotationAssertion(rdfs:label :JointState "Joint state") +AnnotationAssertion(rdfs:comment :JointState "The state of a joint in terms of position, velocity of the joint and effort applied to it."^^xsd:string) +AnnotationAssertion(rdfs:label :JointState "Joint state"^^xsd:string) SubClassOf(:JointState ) SubClassOf(:JointState DataExactCardinality(1 :hasJointPosition xsd:double)) SubClassOf(:JointState DataExactCardinality(1 :hasJointVelocity xsd:double)) @@ -1263,21 +1289,21 @@ SubClassOf(:JointState DataMaxCardinality(1 :hasJointEffort xsd:double)) # Class: :MovableJoint (Movable joint) -AnnotationAssertion(rdfs:comment :MovableJoint "A joint where the two connected links can move relative to each other in some dimension.") -AnnotationAssertion(rdfs:label :MovableJoint "Movable joint") +AnnotationAssertion(rdfs:comment :MovableJoint "A joint where the two connected links can move relative to each other in some dimension."^^xsd:string) +AnnotationAssertion(rdfs:label :MovableJoint "Movable joint"^^xsd:string) SubClassOf(:MovableJoint :Joint) SubClassOf(:MovableJoint ObjectExactCardinality(1 :hasJointState :JointState)) # Class: :NetForce (Net force) -AnnotationAssertion(rdfs:comment :NetForce "The accumulated force acting upon an object.") -AnnotationAssertion(rdfs:label :NetForce "Net force") +AnnotationAssertion(rdfs:comment :NetForce "The accumulated force acting upon an object."^^xsd:string) +AnnotationAssertion(rdfs:label :NetForce "Net force"^^xsd:string) SubClassOf(:NetForce :ForceAttribute) # Class: :PlanarJoint (Planar joint) -AnnotationAssertion(rdfs:comment :PlanarJoint "A joint that allows motion in a plane perpendicular to an axis.") -AnnotationAssertion(rdfs:label :PlanarJoint "Planar joint") +AnnotationAssertion(rdfs:comment :PlanarJoint "A joint that allows motion in a plane perpendicular to an axis."^^xsd:string) +AnnotationAssertion(rdfs:label :PlanarJoint "Planar joint"^^xsd:string) SubClassOf(:PlanarJoint :MovableJoint) # Class: :Pourable (:Pourable) @@ -1286,22 +1312,23 @@ AnnotationAssertion(rdfs:comment :Pourable "The disposition of a fluid or substa SubClassOf(:Pourable SOMA:Disposition) SubClassOf(:Pourable ObjectAllValuesFrom(SOMA:affordsBearer :PouredObject)) -# Class: :PouredObject (:PouredObject) +# Class: :PouredObject (Poured object) AnnotationAssertion(rdfs:comment :PouredObject "An object being poured into or onto some other object. A role of some fluid or substance that is the patient of pouring task.") +AnnotationAssertion(rdfs:label :PouredObject "Poured object") SubClassOf(:PouredObject SOMA:Patient) # Class: :PrismaticJoint (Prismatic joint) -AnnotationAssertion(rdfs:comment :PrismaticJoint "A sliding joint that slides along an axis, and has a limited range specified by the upper and lower limits.") -AnnotationAssertion(rdfs:label :PrismaticJoint "Prismatic joint") +AnnotationAssertion(rdfs:comment :PrismaticJoint "A sliding joint that slides along an axis, and has a limited range specified by the upper and lower limits."^^xsd:string) +AnnotationAssertion(rdfs:label :PrismaticJoint "Prismatic joint"^^xsd:string) SubClassOf(:PrismaticJoint :MovableJoint) SubClassOf(:PrismaticJoint ObjectExactCardinality(1 :hasJointLimit :JointLimit)) # Class: :RevoluteJoint (Revolute joint) -AnnotationAssertion(rdfs:comment :RevoluteJoint "A hinge joint that rotates along an axis and has a limited range specified by the upper and lower limits.") -AnnotationAssertion(rdfs:label :RevoluteJoint "Revolute joint") +AnnotationAssertion(rdfs:comment :RevoluteJoint "A hinge joint that rotates along an axis and has a limited range specified by the upper and lower limits."^^xsd:string) +AnnotationAssertion(rdfs:label :RevoluteJoint "Revolute joint"^^xsd:string) SubClassOf(:RevoluteJoint :HingeJoint) SubClassOf(:RevoluteJoint ObjectExactCardinality(1 :hasJointLimit :JointLimit)) @@ -1411,7 +1438,7 @@ SubClassOf(SOMA:Capacity SOMA:Intrinsic) AnnotationAssertion(rdfs:comment SOMA:CausalEventRole "A role filled by a description of some action or process that brings about a motion. -As an example, consider the utterance \"the tennisman served the ball by hitting it with the racket.\" In this utterance, the filler of the CausalEventRole is expressed by the \"by hitting it with the racket\" constituent.") +As an example, consider the utterance \"the tennisman served the ball by hitting it with the racket.\" In this utterance, the filler of the CausalEventRole is expressed by the \"by hitting it with the racket\" constituent."^^xsd:string) AnnotationAssertion(rdfs:label SOMA:CausalEventRole "Causal event role"@en) SubClassOf(SOMA:CausalEventRole SOMA:CausativeRole) @@ -1632,11 +1659,11 @@ SubClassOf(SOMA:Dirty SOMA:CleanlinessRegion) # Class: SOMA:Disposition (SOMA:Disposition) -AnnotationAssertion(rdfs:comment SOMA:Disposition "The tendency of an object (the bearer) to be used to perform certain tasks with others (the triggers).") +AnnotationAssertion(rdfs:comment SOMA:Disposition "The tendency of an object (the bearer) to make certain events happen with others (the triggers).") AnnotationAssertion(rdfs:comment SOMA:Disposition "extrinsic") SubClassOf(SOMA:Disposition SOMA:Extrinsic) SubClassOf(SOMA:Disposition ObjectExactCardinality(1 SOMA:Affordance)) -SubClassOf(SOMA:Disposition ObjectExactCardinality(1 ObjectIntersectionOf(SOMA:Affordance ObjectExactCardinality(1 SOMA:definesBearer ) ObjectExactCardinality(1 SOMA:definesTrigger ) ObjectExactCardinality(1 )))) +SubClassOf(SOMA:Disposition ObjectExactCardinality(1 ObjectIntersectionOf(SOMA:Affordance ObjectExactCardinality(1 SOMA:definesBearer ) ObjectExactCardinality(1 SOMA:definesEventType ) ObjectExactCardinality(1 SOMA:definesTrigger )))) # Class: SOMA:Effort (SOMA:Effort) @@ -1664,11 +1691,17 @@ AnnotationAssertion(rdfs:label SOMA:EventAdjacentRole "Event adjacent role"@en) AnnotationAssertion(rdfs:label SOMA:EventAdjacentRole "Thematic role"@en) SubClassOf(SOMA:EventAdjacentRole ) +# Class: SOMA:ExcludedObject (Excluded object) + +AnnotationAssertion(rdfs:comment SOMA:ExcludedObject "An object that is not contained in something. This is meant very general and includes, e.g., elements excluded from a set, or things that are spatially excluded from the boundaries of some object.") +AnnotationAssertion(rdfs:label SOMA:ExcludedObject "Excluded object") +SubClassOf(SOMA:ExcludedObject SOMA:Patient) + # Class: SOMA:ExistingObjectRole (Existing object role) AnnotationAssertion(rdfs:comment SOMA:ExistingObjectRole "A role that requires of its filler simply to exist, unlike other roles that may demand e.g. agentive or instrumental participation in some executable schema or plan (AgentRole and Instrument respectively). -The intention behind such a simple role is to have a way to represent, in a schematic formalism used to describe some scene, that an object is present. In particular, the schema used to convey this information is the ESTSchemaTheory, which has ExistingObjectRole as its sole defined role.") +The intention behind such a simple role is to have a way to represent, in a schematic formalism used to describe some scene, that an object is present. In particular, the schema used to convey this information is the ESTSchemaTheory, which has ExistingObjectRole as its sole defined role."^^xsd:string) AnnotationAssertion(rdfs:label SOMA:ExistingObjectRole "Existing object role"@en) SubClassOf(SOMA:ExistingObjectRole SOMA:RelationAdjacentRole) SubClassOf(SOMA:ExistingObjectRole ObjectAllValuesFrom( )) @@ -1677,7 +1710,7 @@ SubClassOf(SOMA:ExistingObjectRole ObjectAllValuesFrom( )) @@ -1897,7 +1930,7 @@ SubClassOf(SOMA:Origin SOMA:Location) # Class: SOMA:PathRole (Path role) -AnnotationAssertion(rdfs:comment SOMA:PathRole "A role that classifies the path of a motion.") +AnnotationAssertion(rdfs:comment SOMA:PathRole "A role that classifies the path of a motion."^^xsd:string) AnnotationAssertion(rdfs:label SOMA:PathRole "Path role"@en) SubClassOf(SOMA:PathRole SOMA:SpatioTemporalRole) @@ -1906,9 +1939,19 @@ SubClassOf(SOMA:PathRole SOMA:SpatioTemporalRole) AnnotationAssertion(rdfs:comment SOMA:Patient "A role classifying an object that undergoes/is the primary object affected by the event.") SubClassOf(SOMA:Patient SOMA:EventAdjacentRole) + +# Class: SOMA:PerformerRole (Performer role) + +AnnotationAssertion(rdfs:comment SOMA:PerformerRole "A role classifying an Agent responsible for performing an Action. + +The entity playing an AgentRole is endowed with sentience and the capacity to deliberately choose actions in pursuit of goals. This distinguishes Agents from other causes that could bring an event about.") +AnnotationAssertion(rdfs:label SOMA:PerformerRole "Performer role"@en) +SubClassOf(SOMA:PerformerRole SOMA:CausativeRole) +SubClassOf(SOMA:PerformerRole ObjectAllValuesFrom( )) + # Class: SOMA:PhysicalEffector (Physical effector) -AnnotationAssertion(rdfs:comment SOMA:PhysicalEffector "A functional part belonging to an Agent and which allows that Agent to act upon its surroundings.") +AnnotationAssertion(rdfs:comment SOMA:PhysicalEffector "A functional part belonging to an Agent and which allows that Agent to act upon its surroundings."^^xsd:string) AnnotationAssertion(rdfs:label SOMA:PhysicalEffector "Physical effector") SubClassOf(SOMA:PhysicalEffector SOMA:FunctionalPart) SubClassOf(SOMA:PhysicalEffector ObjectSomeValuesFrom(ObjectInverseOf() )) @@ -1964,7 +2007,7 @@ SubClassOf(SOMA:RelationAdjacentRole )) @@ -1975,6 +2018,12 @@ AnnotationAssertion(rdfs:comment SOMA:RelevantPart "Features that are relevant p AnnotationAssertion(rdfs:label SOMA:RelevantPart "Relevant part"@en) SubClassOf(SOMA:RelevantPart SOMA:Feature) +# Class: SOMA:RemovedObject (Removed object) + +AnnotationAssertion(rdfs:comment SOMA:RemovedObject "An object that is removed from another.") +AnnotationAssertion(rdfs:label SOMA:RemovedObject "Removed object") +SubClassOf(SOMA:RemovedObject SOMA:ExcludedObject) + # Class: SOMA:ResourceRole (Resource role) AnnotationAssertion(rdfs:comment SOMA:ResourceRole "A role classifying objects that are useful or even necessary to sustain the unfolding of an event. @@ -2206,12 +2255,14 @@ SubClassOf( DataExactCardinality(1 SubObjectPropertyOf(ObjectPropertyChain(SOMA:isBearerDefinedIn ) SOMA:isBearerAffordedBy) SubObjectPropertyOf(ObjectPropertyChain(SOMA:isDefinedInAffordance ) SOMA:isConceptAffordedBy) +SubObjectPropertyOf(ObjectPropertyChain(SOMA:isPerformerDefinedIn ) SOMA:isPerformerAffordedBy) SubObjectPropertyOf(ObjectPropertyChain(SOMA:isSetpointDefinedIn ) SOMA:isSetpointAffordedBy) SubObjectPropertyOf(ObjectPropertyChain(SOMA:isTaskDefinedInAffordance ) SOMA:isTaskAffordedBy) SubObjectPropertyOf(ObjectPropertyChain(SOMA:isTriggerDefinedIn ) SOMA:isTriggerAffordedBy) SubObjectPropertyOf(ObjectPropertyChain( SOMA:affordanceDefines) SOMA:affordsConcept) SubObjectPropertyOf(ObjectPropertyChain( SOMA:affordanceDefinesTask) SOMA:affordsTask) SubObjectPropertyOf(ObjectPropertyChain( SOMA:definesBearer) SOMA:affordsBearer) +SubObjectPropertyOf(ObjectPropertyChain( SOMA:definesPerformer) SOMA:affordsPerformer) SubObjectPropertyOf(ObjectPropertyChain( SOMA:definesSetpoint) SOMA:affordsSetpoint) SubObjectPropertyOf(ObjectPropertyChain( SOMA:definesTrigger) SOMA:affordsTrigger) ) \ No newline at end of file diff --git a/owl/SOMA-PROC.owl b/owl/SOMA-PROC.owl index 82a14007..17c049a2 100755 --- a/owl/SOMA-PROC.owl +++ b/owl/SOMA-PROC.owl @@ -111,7 +111,7 @@ Declaration(ObjectProperty( (defines process) +# Object Property: SOMA:definesProcess (defines process) AnnotationAssertion(rdfs:comment SOMA:definesProcess "A relation between a description and a process type.") AnnotationAssertion(rdfs:label SOMA:definesProcess "defines process") @@ -120,7 +120,7 @@ InverseObjectProperties(SOMA:definesProcess SOMA:isProcessDefinedIn) ObjectPropertyDomain(SOMA:definesProcess ) ObjectPropertyRange(SOMA:definesProcess SOMA:ProcessType) -# Object Property: (has process type) +# Object Property: SOMA:hasProcessType (has process type) AnnotationAssertion(rdfs:comment SOMA:hasProcessType "A relation between roles and process types, e.g. a catalysator is needed to trigger some chemical reaction.") AnnotationAssertion(rdfs:label SOMA:hasProcessType "has process type") @@ -129,7 +129,7 @@ InverseObjectProperties(SOMA:hasProcessType SOMA:isProcessTypeOf) ObjectPropertyDomain(SOMA:hasProcessType ) ObjectPropertyRange(SOMA:hasProcessType SOMA:ProcessType) -# Object Property: (interacts with) +# Object Property: SOMA:interactsWith (interacts with) AnnotationAssertion(rdfs:comment SOMA:interactsWith "A relation between objects that interact with each other.") AnnotationAssertion(rdfs:label SOMA:interactsWith "interacts with") @@ -138,7 +138,7 @@ SymmetricObjectProperty(SOMA:interactsWith) ObjectPropertyDomain(SOMA:interactsWith ) ObjectPropertyRange(SOMA:interactsWith ) -# Object Property: (is process defined in) +# Object Property: SOMA:isProcessDefinedIn (is process defined in) AnnotationAssertion(rdfs:comment SOMA:isProcessDefinedIn "A relation between a process type and a description that defines it.") AnnotationAssertion(rdfs:label SOMA:isProcessDefinedIn "is process defined in") @@ -146,7 +146,7 @@ SubObjectPropertyOf(SOMA:isProcessDefinedIn ) -# Object Property: (is process type of) +# Object Property: SOMA:isProcessTypeOf (is process type of) AnnotationAssertion(rdfs:comment SOMA:isProcessTypeOf "A relation between roles and process types, e.g. a catalysator is needed to trigger some chemical reaction.") AnnotationAssertion(rdfs:label SOMA:isProcessTypeOf "is process type of") @@ -154,13 +154,13 @@ SubObjectPropertyOf(SOMA:isProcessTypeOf ) -# Object Property: (is supported by) +# Object Property: SOMA:isSupportedBy (is supported by) AnnotationAssertion(rdfs:comment SOMA:isSupportedBy "A relation between an object (the supporter) and another object (the supportee) where the supporter cancels the effect of gravity on the supportee.") AnnotationAssertion(rdfs:label SOMA:isSupportedBy "is supported by") SubObjectPropertyOf(SOMA:isSupportedBy SOMA:interactsWith) -# Object Property: () +# Object Property: SOMA:supports (SOMA:supports) AnnotationAssertion(rdfs:comment SOMA:supports "A relation between an object (the supporter) and another object (the supportee) where the supporter cancels the effect of gravity on the supportee.") SubObjectPropertyOf(SOMA:supports SOMA:interactsWith) @@ -171,34 +171,34 @@ SubObjectPropertyOf(SOMA:supports SOMA:interactsWith) # Classes ############################ -# Class: () +# Class: SOMA:Agonist (SOMA:Agonist) AnnotationAssertion(rdfs:comment SOMA:Agonist "A role that classifies entities with a tendency to either cause an alteration or to preserve some state.") SubClassOf(SOMA:Agonist SOMA:Patient) -# Class: () +# Class: SOMA:Alteration (SOMA:Alteration) AnnotationAssertion(rdfs:comment SOMA:Alteration "A process by which an aspect of some object changes such as ice cream melting in the sun.") SubClassOf(SOMA:Alteration SOMA:ProcessType) -# Class: (Alterative interaction) +# Class: SOMA:AlterativeInteraction (Alterative interaction) AnnotationAssertion(rdfs:comment SOMA:AlterativeInteraction "A force interaction where the agonist has the tendency to set another object into motion. An example is 'opening a door' where some object interacts with the door such that it moves out of its frame.") AnnotationAssertion(rdfs:label SOMA:AlterativeInteraction "Alterative interaction") SubClassOf(SOMA:AlterativeInteraction SOMA:ForceInteraction) DisjointClasses(SOMA:AlterativeInteraction SOMA:PreservativeInteraction) -# Class: () +# Class: SOMA:Antagonist (SOMA:Antagonist) AnnotationAssertion(rdfs:comment SOMA:Antagonist "A role that classifies entities that are opposed to the tendency of some agonist.") SubClassOf(SOMA:Antagonist SOMA:Patient) -# Class: () +# Class: SOMA:Approaching (SOMA:Approaching) AnnotationAssertion(rdfs:comment SOMA:Approaching "A process type to classify motions by which a body approaches some object or location.") SubClassOf(SOMA:Approaching SOMA:Locomotion) -# Class: () +# Class: SOMA:BodyMovement (SOMA:BodyMovement) AnnotationAssertion(rdfs:comment SOMA:BodyMovement "Motion described in terms of how parts of an Agent's body move. @@ -206,12 +206,12 @@ As such, this concept can be applied only to motions involving some PhysicalAgen SubClassOf(SOMA:BodyMovement SOMA:Motion) SubClassOf(SOMA:BodyMovement ObjectAllValuesFrom( ObjectUnionOf(ObjectSomeValuesFrom( ) ObjectSomeValuesFrom( ObjectIntersectionOf( ObjectSomeValuesFrom( )))))) -# Class: () +# Class: SOMA:Boiling (SOMA:Boiling) AnnotationAssertion(rdfs:comment SOMA:Boiling "In each instance of this collection some liquid matter is raised to its boilingPoint and is thereby changed from being in the Liquid-StateOfMatter to being in the Gaseous-StateOfMatter.") SubClassOf(SOMA:Boiling SOMA:Vaporizing) -# Class: (Chemical process) +# Class: SOMA:ChemicalProcess (Chemical process) AnnotationAssertion(rdfs:comment SOMA:ChemicalProcess "A process by which the chemical constituency of an Entity or set of Entities changes. @@ -219,12 +219,12 @@ In some sense any process that results in entities being created or destroyed mi AnnotationAssertion(rdfs:label SOMA:ChemicalProcess "Chemical process") SubClassOf(SOMA:ChemicalProcess ) -# Class: () +# Class: SOMA:Collision (SOMA:Collision) AnnotationAssertion(rdfs:comment SOMA:Collision "A contact event of objects bumping into each other such that their movement is affected.") SubClassOf(SOMA:Collision SOMA:ProcessType) -# Class: (Creation) +# Class: SOMA:Creation (Creation) AnnotationAssertion(rdfs:comment SOMA:Creation "A process by which an Entity is created in the physical world. @@ -233,7 +233,7 @@ AnnotationAssertion(rdfs:label SOMA:Creation "Creation") SubClassOf(SOMA:Creation SOMA:ProcessType) SubClassOf(SOMA:Creation ObjectSomeValuesFrom(SOMA:isProcessTypeOf SOMA:CreatedObject)) -# Class: () +# Class: SOMA:Deformation (SOMA:Deformation) AnnotationAssertion(rdfs:comment SOMA:Deformation "A process by which a physical Entity changes its shape under the influence of some factors outside of the Entity. @@ -244,7 +244,7 @@ SubClassOf(SOMA:Deformation SOMA:Alteration) SubClassOf(SOMA:Deformation ObjectExactCardinality(1 SOMA:isProcessTypeOf SOMA:ShapedObject)) DisjointClasses(SOMA:Deformation SOMA:FluidFlow) -# Class: (Destruction) +# Class: SOMA:Destruction (Destruction) AnnotationAssertion(rdfs:comment SOMA:Destruction "A process by which a physical Entity is destroyed. @@ -253,14 +253,14 @@ AnnotationAssertion(rdfs:label SOMA:Destruction "Destruction") SubClassOf(SOMA:Destruction SOMA:ProcessType) SubClassOf(SOMA:Destruction ObjectSomeValuesFrom(SOMA:isProcessTypeOf SOMA:DestroyedObject)) -# Class: (Directed motion) +# Class: SOMA:DirectedMotion (Directed motion) AnnotationAssertion(rdfs:comment SOMA:DirectedMotion "A Motion that is considered to be toward a location or along a path. It is not important that the final location or path be the intention of some Agent, but it is considered that the important feature of this Motion is that it has a path and/or destination.") AnnotationAssertion(rdfs:label SOMA:DirectedMotion "Directed motion") SubClassOf(SOMA:DirectedMotion SOMA:Motion) DisjointClasses(SOMA:DirectedMotion SOMA:UndirectedMotion) -# Class: () +# Class: SOMA:Driving (SOMA:Driving) AnnotationAssertion(rdfs:comment SOMA:Driving "A process type classifying a motion of a body that exists because this body is attached to and controls some other moving body, usually a vehicle.") SubClassOf(SOMA:Driving SOMA:Locomotion) @@ -268,7 +268,7 @@ DisjointClasses(SOMA:Driving SOMA:Flying) DisjointClasses(SOMA:Driving SOMA:Swimming) DisjointClasses(SOMA:Driving SOMA:Walking) -# Class: (Fluid flow) +# Class: SOMA:FluidFlow (Fluid flow) AnnotationAssertion(rdfs:comment SOMA:FluidFlow "A process by which a fluid moves or is moved from a location to another, but such that it maintains its constitution. A fluid is an Entity made of many smaller Entities, loosely bound to each other. @@ -277,14 +277,14 @@ AnnotationAssertion(rdfs:label SOMA:FluidFlow "Fluid flow") SubClassOf(SOMA:FluidFlow SOMA:Motion) SubClassOf(SOMA:FluidFlow ObjectSomeValuesFrom(SOMA:isProcessTypeOf SOMA:MovedObject)) -# Class: () +# Class: SOMA:Flying (SOMA:Flying) AnnotationAssertion(rdfs:comment SOMA:Flying "A process type classifying a motion of a body that, through its own power, keeps itself aloft.") SubClassOf(SOMA:Flying SOMA:Locomotion) DisjointClasses(SOMA:Flying SOMA:Swimming) DisjointClasses(SOMA:Flying SOMA:Walking) -# Class: (Force interaction) +# Class: SOMA:ForceInteraction (Force interaction) AnnotationAssertion(rdfs:comment SOMA:ForceInteraction "Classifies events in which two entities interact with each other with a reference to force. One of the entities, the agonist, has a tendency to either set the other entity (the antagonist) into motion, or to keep it still under the influence of some other force. The tendency only manifests in case the agonist is the \"stronger entity\".") AnnotationAssertion(rdfs:label SOMA:ForceInteraction "Force interaction") @@ -294,7 +294,7 @@ SubClassOf(SOMA:ForceInteraction SOMA:ProcessType) SubClassOf(SOMA:ForceInteraction ObjectSomeValuesFrom(SOMA:isProcessTypeOf SOMA:Agonist)) SubClassOf(SOMA:ForceInteraction ObjectSomeValuesFrom(SOMA:isProcessTypeOf SOMA:Antagonist)) -# Class: (Grasping motion) +# Class: SOMA:GraspingMotion (Grasping motion) AnnotationAssertion(rdfs:comment SOMA:GraspingMotion "A process type classifying a motion by which some end effector acquires kinematic control over some other object.") AnnotationAssertion(rdfs:label SOMA:GraspingMotion "Grasping motion") @@ -302,18 +302,18 @@ EquivalentClasses(SOMA:GraspingMotion ObjectUnionOf(SOMA:IntermediateGrasp SOMA: SubClassOf(SOMA:GraspingMotion SOMA:PrehensileMotion) DisjointClasses(SOMA:GraspingMotion SOMA:ReleasingMotion) -# Class: () +# Class: SOMA:HeadMovement (SOMA:HeadMovement) AnnotationAssertion(rdfs:comment SOMA:HeadMovement "The Agent moves a part of their body carrying high-bandwidth sensors such as cameras. The movement of other body parts is not significant.") AnnotationAssertion(rdfs:comment SOMA:HeadMovement "todo: (Mihai:) This seems too specific, given the \"Directed\"/\"Undirected motion\" categories.") SubClassOf(SOMA:HeadMovement SOMA:BodyMovement) -# Class: () +# Class: SOMA:HeadTurning (SOMA:HeadTurning) AnnotationAssertion(rdfs:comment SOMA:HeadTurning "A process type classifying a motion of an Agent's head such that the direction this head faces changes relative to the facing direction of the Agent's body as a whole.") SubClassOf(SOMA:HeadTurning SOMA:HeadMovement) -# Class: (Intermediate grasp) +# Class: SOMA:IntermediateGrasp (Intermediate grasp) AnnotationAssertion(rdfs:comment SOMA:IntermediateGrasp "A kind of grasp that acquires kinematic control over the gripped object, but without attempting to achieve either strong holding force nor precision of subsequent movement of the gripped object.") AnnotationAssertion(rdfs:label SOMA:IntermediateGrasp "Intermediate grasp") @@ -321,12 +321,12 @@ SubClassOf(SOMA:IntermediateGrasp SOMA:GraspingMotion) DisjointClasses(SOMA:IntermediateGrasp SOMA:PowerGrasp) DisjointClasses(SOMA:IntermediateGrasp SOMA:PrecisionGrasp) -# Class: () +# Class: SOMA:Leaning (SOMA:Leaning) AnnotationAssertion(rdfs:comment SOMA:Leaning "An Agent pitches its body in some direction.") SubClassOf(SOMA:Leaning SOMA:PosturalMoving) -# Class: (Limb motion) +# Class: SOMA:LimbMotion (Limb motion) AnnotationAssertion(rdfs:comment SOMA:LimbMotion "An Agent moves its limbs in some way.") AnnotationAssertion(rdfs:label SOMA:LimbMotion "Limb motion") @@ -335,7 +335,7 @@ SubClassOf(SOMA:LimbMotion ObjectSomeValuesFrom(SOMA:isProcessTypeOf ObjectInter DisjointClasses(SOMA:LimbMotion SOMA:Locomotion) DisjointClasses(SOMA:LimbMotion SOMA:PrehensileMotion) -# Class: () +# Class: SOMA:Locomotion (SOMA:Locomotion) AnnotationAssertion(rdfs:comment SOMA:Locomotion "Conceptually related to Navigation, but distinguishable from it because of the profile, ie. the focus of the task. @@ -347,18 +347,18 @@ SubClassOf(SOMA:Locomotion SOMA:BodyMovement) SubClassOf(SOMA:Locomotion SOMA:DirectedMotion) DisjointClasses(SOMA:Locomotion SOMA:PrehensileMotion) -# Class: () +# Class: SOMA:Motion (SOMA:Motion) AnnotationAssertion(rdfs:comment SOMA:Motion "An EventType that classifies motion Processes.") AnnotationAssertion(rdfs:comment SOMA:Motion "Motion type") SubClassOf(SOMA:Motion SOMA:ProcessType) -# Class: () +# Class: SOMA:MovingAway (SOMA:MovingAway) AnnotationAssertion(rdfs:comment SOMA:MovingAway "A process type classifying a motion by which some Agent puts distance between itself and another object or location.") SubClassOf(SOMA:MovingAway SOMA:Locomotion) -# Class: (Phase transition) +# Class: SOMA:PhaseTransition (Phase transition) AnnotationAssertion(rdfs:comment SOMA:PhaseTransition "An EventType that classifies processes by which matter changes from some distinguishable phase to another. We will use this to refer to the classical phase transitions between Solid, Liquid, Gaseous, Plasma etc. phases.") AnnotationAssertion(rdfs:label SOMA:PhaseTransition "Phase transition") @@ -367,34 +367,34 @@ AnnotationAssertion(rdfs:seeAlso SOMA:PhaseTransition "The phase transition conc In all these cases, the metaphor points to the existence of several regions of qualitatively different behavior (unimpeded passage of solid grains vs deadlock in a corridor; problem instances where the answer NO is trivial to prove vs. problem instances where the answer YES is trivial to prove), separated fairly sharply when some quantity reaches a threshold.") SubClassOf(SOMA:PhaseTransition SOMA:Alteration) -# Class: (Physical process) +# Class: SOMA:PhysicsProcess (Physical process) AnnotationAssertion(rdfs:comment SOMA:PhysicsProcess "A process involving physical objects and phenomena which does not change the chemical constituency of the affected objects.") AnnotationAssertion(rdfs:label SOMA:PhysicsProcess "Physical process") SubClassOf(SOMA:PhysicsProcess ) SubClassOf(SOMA:PhysicsProcess ObjectSomeValuesFrom( )) -# Class: () +# Class: SOMA:PosturalMoving (SOMA:PosturalMoving) AnnotationAssertion(rdfs:comment SOMA:PosturalMoving "The Agent changes or takes an overall configuration of its body but is otherwise not significantly affecting other objects nor moving a significant amount from its original location. Posture changes may take place as part of other actions, for example turning when walking.") SubClassOf(SOMA:PosturalMoving SOMA:BodyMovement) -# Class: (Power grasp) +# Class: SOMA:PowerGrasp (Power grasp) AnnotationAssertion(rdfs:comment SOMA:PowerGrasp "An Agent grasps an object, and focuses on obtaining a strong grasping force upon it, resulting in a grasp able to resist significant outside disturbances. This is useful when using tools with which to later exert force on other things, e.g. when hammering nails.") AnnotationAssertion(rdfs:label SOMA:PowerGrasp "Power grasp") SubClassOf(SOMA:PowerGrasp SOMA:GraspingMotion) DisjointClasses(SOMA:PowerGrasp SOMA:PrecisionGrasp) -# Class: (Precision grasp) +# Class: SOMA:PrecisionGrasp (Precision grasp) AnnotationAssertion(rdfs:comment SOMA:PrecisionGrasp "An Agent grasps an object, and focuses on obtaining precise kinematic control over it. This is useful for then following precise movements, e.g. when writing.") AnnotationAssertion(rdfs:label SOMA:PrecisionGrasp "Precision grasp") SubClassOf(SOMA:PrecisionGrasp SOMA:GraspingMotion) -# Class: (Prehensile motion) +# Class: SOMA:PrehensileMotion (Prehensile motion) AnnotationAssertion(rdfs:comment SOMA:PrehensileMotion "A motion of a prehensile effector.") AnnotationAssertion(rdfs:label SOMA:PrehensileMotion "Prehensile motion") @@ -402,20 +402,20 @@ EquivalentClasses(SOMA:PrehensileMotion ObjectUnionOf(SOMA:GraspingMotion SOMA:R SubClassOf(SOMA:PrehensileMotion SOMA:DirectedMotion) SubClassOf(SOMA:PrehensileMotion ObjectSomeValuesFrom(SOMA:isProcessTypeOf ObjectIntersectionOf(SOMA:MovedObject ObjectAllValuesFrom( SOMA:PrehensileEffector)))) -# Class: (Preservative interaction) +# Class: SOMA:PreservativeInteraction (Preservative interaction) AnnotationAssertion(rdfs:comment SOMA:PreservativeInteraction "A force interaction where the agonist has a tendency to keep another object still. An example is 'holding a door closed' where some object interacts with the door to neutralize forces that could set the door into motion.") AnnotationAssertion(rdfs:label SOMA:PreservativeInteraction "Preservative interaction") SubClassOf(SOMA:PreservativeInteraction SOMA:ForceInteraction) -# Class: (Process flow) +# Class: SOMA:ProcessFlow (Process flow) AnnotationAssertion(rdfs:comment SOMA:ProcessFlow "A description that structures a Process.") AnnotationAssertion(rdfs:label SOMA:ProcessFlow "Process flow") SubClassOf(SOMA:ProcessFlow ) SubClassOf(SOMA:ProcessFlow ObjectSomeValuesFrom(SOMA:definesProcess SOMA:ProcessType)) -# Class: (Process type) +# Class: SOMA:ProcessType (Process type) AnnotationAssertion(rdfs:comment SOMA:ProcessType "An EventType that classifies Processes.") AnnotationAssertion(rdfs:label SOMA:ProcessType "Process type") @@ -424,63 +424,63 @@ SubClassOf(SOMA:ProcessType ObjectAllValuesFrom( SOMA:ProcessType)) SubClassOf(SOMA:ProcessType ObjectAllValuesFrom( )) -# Class: () +# Class: SOMA:Progression (SOMA:Progression) AnnotationAssertion(rdfs:comment SOMA:Progression "A situation that sattisies a description of how a process evolves over time.") EquivalentClasses(SOMA:Progression ObjectSomeValuesFrom( SOMA:ProcessFlow)) SubClassOf(SOMA:Progression ) -# Class: (Releasing motion) +# Class: SOMA:ReleasingMotion (Releasing motion) AnnotationAssertion(rdfs:comment SOMA:ReleasingMotion "A motion by which a prehensile effector relinquishes kinematic control over an object.") AnnotationAssertion(rdfs:label SOMA:ReleasingMotion "Releasing motion") SubClassOf(SOMA:ReleasingMotion SOMA:PrehensileMotion) -# Class: () +# Class: SOMA:Rubbing (SOMA:Rubbing) AnnotationAssertion(rdfs:comment SOMA:Rubbing "The motion of an object sliding along the surface of another, for example, to clean the surface.") SubClassOf(SOMA:Rubbing SOMA:DirectedMotion) -# Class: () +# Class: SOMA:Standing (SOMA:Standing) AnnotationAssertion(rdfs:comment SOMA:Standing "A motion by which an Agent arranges its body in an upright configuration. Typically, it makes sense to speak of standing for bodies where some limbs are dedicated to moving the whole body while some limbs are used for manipulation of other objects.") SubClassOf(SOMA:Standing SOMA:PosturalMoving) -# Class: () +# Class: SOMA:Swimming (SOMA:Swimming) AnnotationAssertion(rdfs:comment SOMA:Swimming "A motion of some body through water. The body provides the power for the motion.") SubClassOf(SOMA:Swimming SOMA:Locomotion) DisjointClasses(SOMA:Swimming SOMA:Walking) -# Class: () +# Class: SOMA:Tapping (SOMA:Tapping) AnnotationAssertion(rdfs:comment SOMA:Tapping "A motion, usually repeated several times, for example, to probe the surface of an object.") SubClassOf(SOMA:Tapping SOMA:DirectedMotion) -# Class: () +# Class: SOMA:Taxis (SOMA:Taxis) AnnotationAssertion(rdfs:comment SOMA:Taxis "An innate behavioural response such as the knee-jerk reflex or the sucking reflex of human infants.") SubClassOf(SOMA:Taxis SOMA:BodyMovement) -# Class: () +# Class: SOMA:Turning (SOMA:Turning) AnnotationAssertion(rdfs:comment SOMA:Turning "A motion by which an agent changes which way their body faces.") SubClassOf(SOMA:Turning SOMA:PosturalMoving) -# Class: (Undirected motion) +# Class: SOMA:UndirectedMotion (Undirected motion) AnnotationAssertion(rdfs:comment SOMA:UndirectedMotion "A Motion of a physical Entity for which a destination or path are unknown and/or considered irrelevant; the important aspect about this Motion is simply that it occurs, rather than where it is headed or how it proceeds towards it.") AnnotationAssertion(rdfs:label SOMA:UndirectedMotion "Undirected motion") SubClassOf(SOMA:UndirectedMotion SOMA:Motion) -# Class: () +# Class: SOMA:Vaporizing (SOMA:Vaporizing) AnnotationAssertion(rdfs:comment SOMA:Vaporizing "Some material transitions from a liquid to a gaseous phase.") AnnotationAssertion(rdfs:seeAlso SOMA:Vaporizing "Transitions from a solid to a gaseous phase are usually referred to as Sublimation.") SubClassOf(SOMA:Vaporizing SOMA:PhaseTransition) SubClassOf(SOMA:Vaporizing ObjectSomeValuesFrom(SOMA:isProcessTypeOf ObjectIntersectionOf(SOMA:AlteredObject ObjectAllValuesFrom( )))) -# Class: () +# Class: SOMA:Walking (SOMA:Walking) AnnotationAssertion(rdfs:comment SOMA:Walking "An agent, under its own power, moves over some solid surface.") SubClassOf(SOMA:Walking SOMA:Locomotion) diff --git a/owl/SOMA-SAY.owl b/owl/SOMA-SAY.owl index ef3d34a1..de223feb 100644 --- a/owl/SOMA-SAY.owl +++ b/owl/SOMA-SAY.owl @@ -42,11 +42,7 @@ Declaration(Class(SOMA:SourcePathGoalTheory)) Declaration(Class(SOMA:State)) Declaration(Class(SOMA:StateTransition)) Declaration(Class(SOMA:SupportTheory)) -Declaration(ObjectProperty(:isInitialSceneOf)) -Declaration(ObjectProperty(:isTerminalSceneOf)) Declaration(ObjectProperty(SOMA:coversObject)) -Declaration(ObjectProperty(SOMA:hasInitialScene)) -Declaration(ObjectProperty(SOMA:hasTerminalScene)) Declaration(ObjectProperty(SOMA:interactsWith)) Declaration(ObjectProperty(SOMA:isAnsweredBy)) Declaration(ObjectProperty(SOMA:isCoveredByObject)) @@ -57,23 +53,7 @@ Declaration(ObjectProperty(SOMA:movesObject)) # Object Properties ############################ -# Object Property: () - -AnnotationAssertion(rdfs:comment :isInitialSceneOf "A relation between StateTransitions and Scenes, which identifies the scene the transition starts from.") -SubObjectPropertyOf(:isInitialSceneOf ) -InverseObjectProperties(:isInitialSceneOf SOMA:hasInitialScene) -ObjectPropertyDomain(:isInitialSceneOf SOMA:Scene) -ObjectPropertyRange(:isInitialSceneOf SOMA:StateTransition) - -# Object Property: () - -AnnotationAssertion(rdfs:comment :isTerminalSceneOf "A relation between StateTransitions and Scenes, which identifies the scene the transition is expected to end at.") -SubObjectPropertyOf(:isTerminalSceneOf ) -InverseObjectProperties(:isTerminalSceneOf SOMA:hasTerminalScene) -ObjectPropertyDomain(:isTerminalSceneOf SOMA:Scene) -ObjectPropertyRange(:isTerminalSceneOf SOMA:StateTransition) - -# Object Property: () +# Object Property: SOMA:coversObject (SOMA:coversObject) AnnotationAssertion(rdfs:comment SOMA:coversObject "A relationship from an object (the coverer) that blocks access to another or its interior (the coveree).") SubObjectPropertyOf(SOMA:coversObject SOMA:interactsWith) @@ -83,25 +63,7 @@ IrreflexiveObjectProperty(SOMA:coversObject) ObjectPropertyDomain(SOMA:coversObject ) ObjectPropertyRange(SOMA:coversObject ) -# Object Property: () - -AnnotationAssertion(rdfs:comment SOMA:hasInitialScene "A relation between StateTransitions and Scenes, which identifies the scene the transition starts from.") -SubObjectPropertyOf(SOMA:hasInitialScene ) -AsymmetricObjectProperty(SOMA:hasInitialScene) -IrreflexiveObjectProperty(SOMA:hasInitialScene) -ObjectPropertyDomain(SOMA:hasInitialScene SOMA:StateTransition) -ObjectPropertyRange(SOMA:hasInitialScene SOMA:Scene) - -# Object Property: () - -AnnotationAssertion(rdfs:comment SOMA:hasTerminalScene "A relation between StateTransitions and Scenes, which identifies the scene the transition is expected to end at.") -SubObjectPropertyOf(SOMA:hasTerminalScene ) -AsymmetricObjectProperty(SOMA:hasTerminalScene) -IrreflexiveObjectProperty(SOMA:hasTerminalScene) -ObjectPropertyDomain(SOMA:hasTerminalScene SOMA:StateTransition) -ObjectPropertyRange(SOMA:hasTerminalScene SOMA:Scene) - -# Object Property: (is answered by) +# Object Property: SOMA:isAnsweredBy (is answered by) AnnotationAssertion(rdfs:comment SOMA:isAnsweredBy "A relation from a Query to an Agent who answers it.") AnnotationAssertion(rdfs:label SOMA:isAnsweredBy "is answered by") @@ -109,7 +71,7 @@ SubObjectPropertyOf(SOMA:isAnsweredBy ) ObjectPropertyRange(SOMA:isAnsweredBy ) -# Object Property: () +# Object Property: SOMA:isCoveredByObject (SOMA:isCoveredByObject) AnnotationAssertion(rdfs:comment SOMA:isCoveredByObject "A relation from an object (the coveree) which is itself, or has its interior, prevented from being accessed from outside by a coverer.") SubObjectPropertyOf(SOMA:isCoveredByObject SOMA:interactsWith) @@ -118,7 +80,7 @@ IrreflexiveObjectProperty(SOMA:isCoveredByObject) ObjectPropertyDomain(SOMA:isCoveredByObject ) ObjectPropertyRange(SOMA:isCoveredByObject ) -# Object Property: () +# Object Property: SOMA:isMovedByAgent (SOMA:isMovedByAgent) AnnotationAssertion(rdfs:comment SOMA:isMovedByAgent "A relation from an object to an agent who causes it to move.") SubObjectPropertyOf(SOMA:isMovedByAgent SOMA:interactsWith) @@ -126,7 +88,7 @@ InverseObjectProperties(SOMA:isMovedByAgent SOMA:movesObject) ObjectPropertyDomain(SOMA:isMovedByAgent ) ObjectPropertyRange(SOMA:isMovedByAgent ) -# Object Property: () +# Object Property: SOMA:movesObject (SOMA:movesObject) AnnotationAssertion(rdfs:comment SOMA:movesObject "A relation from an agent to an object that the agent causes to move.") SubObjectPropertyOf(SOMA:movesObject SOMA:interactsWith) @@ -139,34 +101,34 @@ ObjectPropertyRange(SOMA:movesObject (Assertion task) +# Class: SOMA:AssertionTask (Assertion task) SubClassOf(SOMA:AssertionTask ObjectAllValuesFrom( ObjectSomeValuesFrom( SOMA:DeclarativeClause))) -# Class: (Caused motion theory) +# Class: SOMA:CausedMotionTheory (Caused motion theory) AnnotationAssertion(rdfs:comment SOMA:CausedMotionTheory "A schematic theory describing a situation in which an agent performs an action which causes an object to move along a certain path. A popular example being \"He sneezed the napkin off the table.\" (Goldberg 1995) Let xA, xP be objects filling the agent, patient roles of this schema. Then one can infer that xA movesObject xP.") AnnotationAssertion(rdfs:label SOMA:CausedMotionTheory "Caused motion theory"@en) SubClassOf(SOMA:CausedMotionTheory SOMA:ImageSchemaTheory) -SubClassOf(SOMA:CausedMotionTheory ObjectSomeValuesFrom( SOMA:AgentRole)) SubClassOf(SOMA:CausedMotionTheory ObjectSomeValuesFrom( SOMA:CausalEventRole)) SubClassOf(SOMA:CausedMotionTheory ObjectSomeValuesFrom( SOMA:Instrument)) SubClassOf(SOMA:CausedMotionTheory ObjectSomeValuesFrom( SOMA:Patient)) +SubClassOf(SOMA:CausedMotionTheory ObjectSomeValuesFrom( SOMA:PerformerRole)) SubClassOf(SOMA:CausedMotionTheory ObjectSomeValuesFrom( SOMA:SourcePathGoalTheory)) -# Class: (Clausal object) +# Class: SOMA:ClausalObject (Clausal object) AnnotationAssertion(rdfs:comment SOMA:ClausalObject "A clause is a phrase containing a subject and a predicate.") AnnotationAssertion(rdfs:label SOMA:ClausalObject "Clausal object") SubClassOf(SOMA:ClausalObject SOMA:Phrase) -# Class: (Commanding task) +# Class: SOMA:CommandingTask (Commanding task) SubClassOf(SOMA:CommandingTask ObjectAllValuesFrom( ObjectSomeValuesFrom( SOMA:ImperativeClause))) -# Class: (Containment theory) +# Class: SOMA:ContainmentTheory (Containment theory) AnnotationAssertion(rdfs:comment SOMA:ContainmentTheory "A schematic theory that describes a functional relation which ensures that the location of some entity, the locatum, is constrained to be within some region which is the interior of some other entity, the relatum. @@ -176,7 +138,7 @@ Let xL, xR be objects filling the locatum, relatum roles of this schema. Then on AnnotationAssertion(rdfs:label SOMA:ContainmentTheory "Containment theory"@en) SubClassOf(SOMA:ContainmentTheory SOMA:ControlTheory) -# Class: (Control theory) +# Class: SOMA:ControlTheory (Control theory) AnnotationAssertion(rdfs:comment SOMA:ControlTheory "A description of functional-spatial configurations where one object controls another object's position in space, e.g. if a pot moves, then the popcorn contained therein moves, as well. Note that the objects do not need to be in direct contact. @@ -184,14 +146,14 @@ Adopted from GUM-4-space (Bateman et al. 2010).") AnnotationAssertion(rdfs:label SOMA:ControlTheory "Control theory"@en) SubClassOf(SOMA:ControlTheory SOMA:FunctionalSpatialSchemaTheory) -# Class: () +# Class: SOMA:CoverageTheory (SOMA:CoverageTheory) AnnotationAssertion(rdfs:comment SOMA:CoverageTheory "A schematic theory of a functional relation between two objects such that one of them, the locatum, blocks access to the interior of the relatum. Let xL, xR be objects filling the locatum, relatum roles of this schema. Then one can infer that xL coversObject xR.") SubClassOf(SOMA:CoverageTheory SOMA:FunctionalSpatialSchemaTheory) -# Class: (Covering theory) +# Class: SOMA:CoveringTheory (Covering theory) AnnotationAssertion(rdfs:comment SOMA:CoveringTheory "A schematic theory of how an agent can use an instrument to prevent access to the interior of a patient.") AnnotationAssertion(rdfs:label SOMA:CoveringTheory "Covering theory"@en) @@ -199,7 +161,7 @@ SubClassOf(SOMA:CoveringTheory SOMA:ExecutableSchematicTheory) SubClassOf(SOMA:CoveringTheory ObjectSomeValuesFrom( SOMA:Instrument)) SubClassOf(SOMA:CoveringTheory ObjectExactCardinality(1 SOMA:Patient)) -# Class: (Cracking theory) +# Class: SOMA:CrackingTheory (Cracking theory) AnnotationAssertion(rdfs:comment SOMA:CrackingTheory "A schematic theory of how an agent can inflict damage to the surface of an object.") AnnotationAssertion(rdfs:label SOMA:CrackingTheory "Cracking theory"@en) @@ -207,13 +169,13 @@ SubClassOf(SOMA:CrackingTheory SOMA:ExecutableSchematicTheory) SubClassOf(SOMA:CrackingTheory ObjectSomeValuesFrom( SOMA:Instrument)) SubClassOf(SOMA:CrackingTheory ObjectSomeValuesFrom( SOMA:Patient)) -# Class: (Declarative clause) +# Class: SOMA:DeclarativeClause (Declarative clause) AnnotationAssertion(rdfs:comment SOMA:DeclarativeClause "A clause which makes an assertion or declaration.") AnnotationAssertion(rdfs:label SOMA:DeclarativeClause "Declarative clause") SubClassOf(SOMA:DeclarativeClause SOMA:ClausalObject) -# Class: (EST schema theory) +# Class: SOMA:ESTSchemaTheory (EST schema theory) AnnotationAssertion(rdfs:comment SOMA:ESTSchemaTheory "A schematic theory that describes the existence of an entity. @@ -227,7 +189,7 @@ SubClassOf(SOMA:ESTSchemaTheory SOMA:ImageSchemaTheory) SubClassOf(SOMA:ESTSchemaTheory ObjectSomeValuesFrom( SOMA:ExistingObjectRole)) SubClassOf(SOMA:ESTSchemaTheory ObjectExactCardinality(1 )) -# Class: (Executable schematic theory) +# Class: SOMA:ExecutableSchematicTheory (Executable schematic theory) AnnotationAssertion(rdfs:comment SOMA:ExecutableSchematicTheory "Also known as \"executing schemas\" or \"x-schemas\", these were defined by Bergen and Chang in their work \"Embodied Construction Grammar in Simulation-Based Language Understanding\" as: @@ -239,9 +201,9 @@ SOMA does not restrict the formalism of ExecutableSchematicTheories; i.e. they d They maintain their role however as representations able to drive a simulation, at some level of abstraction, of an embodied action. This level of abstraction may be still fairly underspecified as in the case of the original x-schemas and as such not a plan that an agent could run in an actual physical environment without further information.") AnnotationAssertion(rdfs:label SOMA:ExecutableSchematicTheory "Executable schematic theory"@en) SubClassOf(SOMA:ExecutableSchematicTheory SOMA:SchematicTheory) -SubClassOf(SOMA:ExecutableSchematicTheory ObjectSomeValuesFrom( SOMA:AgentRole)) +SubClassOf(SOMA:ExecutableSchematicTheory ObjectSomeValuesFrom( SOMA:PerformerRole)) -# Class: (Functional spatial schema theory) +# Class: SOMA:FunctionalSpatialSchemaTheory (Functional spatial schema theory) AnnotationAssertion(rdfs:comment SOMA:FunctionalSpatialSchemaTheory "The superclass for theories describing functional spatial relations. @@ -251,7 +213,7 @@ SubClassOf(SOMA:FunctionalSpatialSchemaTheory SOMA:ImageSchemaTheory) SubClassOf(SOMA:FunctionalSpatialSchemaTheory ObjectSomeValuesFrom( SOMA:LocatumRole)) SubClassOf(SOMA:FunctionalSpatialSchemaTheory ObjectSomeValuesFrom( SOMA:RelatumRole)) -# Class: (Image schema theory) +# Class: SOMA:ImageSchemaTheory (Image schema theory) AnnotationAssertion(rdfs:comment SOMA:ImageSchemaTheory "A theory that describes an image-schematic relationship between some entities. @@ -261,7 +223,7 @@ For SOMA, whereas the focus of executable schematic theories is to describe how AnnotationAssertion(rdfs:label SOMA:ImageSchemaTheory "Image schema theory"@en) SubClassOf(SOMA:ImageSchemaTheory SOMA:SchematicTheory) -# Class: (Imperative clause) +# Class: SOMA:ImperativeClause (Imperative clause) AnnotationAssertion(rdfs:comment SOMA:ImperativeClause "A clause which commands some agent to perform a task or bring about a state of affairs.") AnnotationAssertion(rdfs:label SOMA:ImperativeClause "Imperative clause") @@ -269,7 +231,7 @@ SubClassOf(SOMA:ImperativeClause SOMA:ClausalObject) SubClassOf(SOMA:ImperativeClause ObjectSomeValuesFrom( SOMA:StateTransition)) SubClassOf(SOMA:ImperativeClause ObjectAllValuesFrom( SOMA:StateTransition)) -# Class: (Interrogative clause) +# Class: SOMA:InterrogativeClause (Interrogative clause) AnnotationAssertion(rdfs:comment SOMA:InterrogativeClause "A clause which makes a request, typically information, of some agent. @@ -277,11 +239,11 @@ Note that in a semantic sense such clauses always request information, but in a AnnotationAssertion(rdfs:label SOMA:InterrogativeClause "Interrogative clause") SubClassOf(SOMA:InterrogativeClause SOMA:ClausalObject) -# Class: (Linguistic object) +# Class: SOMA:LinguisticObject (Linguistic object) AnnotationAssertion(rdfs:isDefinedBy SOMA:LinguisticObject ) -# Class: (Locutionary action) +# Class: SOMA:LocutionaryAction (Locutionary action) AnnotationAssertion(rdfs:comment SOMA:LocutionaryAction "A Locutionary Act is the performance of an utterance (source: https://en.wikipedia.org/wiki/Locutionary_act). @@ -289,7 +251,7 @@ We additionally require a Locutionary Act to be performed by an Agent, not an Ac AnnotationAssertion(rdfs:label SOMA:LocutionaryAction "Locutionary action"@en) EquivalentClasses(SOMA:LocutionaryAction ObjectIntersectionOf(SOMA:CommunicationAction ObjectSomeValuesFrom( ))) -# Class: (Mixing theory) +# Class: SOMA:MixingTheory (Mixing theory) AnnotationAssertion(rdfs:comment SOMA:MixingTheory "A schematic theory about how an agent can mix a fluid or particulate object.") AnnotationAssertion(rdfs:label SOMA:MixingTheory "Mixing theory"@en) @@ -297,12 +259,12 @@ SubClassOf(SOMA:MixingTheory SOMA:ExecutableSchematicTheory) SubClassOf(SOMA:MixingTheory ObjectSomeValuesFrom( SOMA:Instrument)) SubClassOf(SOMA:MixingTheory ObjectSomeValuesFrom( SOMA:Patient)) -# Class: () +# Class: SOMA:Phrase (SOMA:Phrase) AnnotationAssertion(rdfs:isDefinedBy SOMA:Phrase ) SubClassOf(SOMA:Phrase SOMA:LinguisticObject) -# Class: (Placing theory) +# Class: SOMA:PlacingTheory (Placing theory) AnnotationAssertion(rdfs:comment SOMA:PlacingTheory "A schematic theory of how an agent can place a patient at a particular goal location.") AnnotationAssertion(rdfs:label SOMA:PlacingTheory "Placing theory"@en) @@ -310,7 +272,7 @@ SubClassOf(SOMA:PlacingTheory SOMA:ExecutableSchematicTheory) SubClassOf(SOMA:PlacingTheory ObjectSomeValuesFrom( SOMA:Destination)) SubClassOf(SOMA:PlacingTheory ObjectSomeValuesFrom( SOMA:Patient)) -# Class: (Proximal theory) +# Class: SOMA:ProximalTheory (Proximal theory) AnnotationAssertion(rdfs:comment SOMA:ProximalTheory "An image schematic theory that describes a qualitative spatial relation indicating relative proximity, as expressed by the prepositions 'near', 'close to', 'next to', etc. @@ -326,18 +288,18 @@ SubClassOf(SOMA:ProximalTheory SOMA:ImageSchemaTheory) SubClassOf(SOMA:ProximalTheory ObjectSomeValuesFrom( SOMA:LocatumRole)) SubClassOf(SOMA:ProximalTheory ObjectSomeValuesFrom( SOMA:RelatumRole)) -# Class: (Querying task) +# Class: SOMA:QueryingTask (Querying task) SubClassOf(SOMA:QueryingTask ObjectAllValuesFrom( ObjectSomeValuesFrom( SOMA:InterrogativeClause))) -# Class: () +# Class: SOMA:Scene (SOMA:Scene) AnnotationAssertion(rdfs:comment SOMA:Scene "Scenes are Situations which interpret a State in terms of its conformance to some qualitative, image schematic description. I.e., the scene is described in terms of qualitative functional and spatial relations existing between participating objects.") SubClassOf(SOMA:Scene ) SubClassOf(SOMA:Scene ObjectSomeValuesFrom( SOMA:State)) SubClassOf(SOMA:Scene ObjectSomeValuesFrom( SOMA:ImageSchemaTheory)) -# Class: (Schematic theory) +# Class: SOMA:SchematicTheory (Schematic theory) AnnotationAssertion(rdfs:comment SOMA:SchematicTheory "A theory used to describe, analyze, and reason with the meaning of a linguistic message. @@ -345,7 +307,7 @@ Note that such theories are useful both when analyzing an actual linguistic prod AnnotationAssertion(rdfs:label SOMA:SchematicTheory "Schematic theory"@en) SubClassOf(SOMA:SchematicTheory ) -# Class: (Source-path-goal theory) +# Class: SOMA:SourcePathGoalTheory (Source-path-goal theory) AnnotationAssertion(rdfs:comment SOMA:SourcePathGoalTheory "A very general image-schema of the Path family, this schema describes movement along a path from a source towards a goal. @@ -358,17 +320,15 @@ SubClassOf(SOMA:SourcePathGoalTheory ObjectSomeValuesFrom( SOMA:Origin)) SubClassOf(SOMA:SourcePathGoalTheory ObjectSomeValuesFrom( SOMA:PathRole)) -# Class: (State transition) +# Class: SOMA:StateTransition (State transition) AnnotationAssertion(rdfs:comment SOMA:StateTransition "A transition between two states brought about by the Action of some Agent.") AnnotationAssertion(rdfs:label SOMA:StateTransition "State transition"@en) SubClassOf(SOMA:StateTransition ) -SubClassOf(SOMA:StateTransition ObjectSomeValuesFrom(SOMA:hasInitialScene SOMA:Scene)) -SubClassOf(SOMA:StateTransition ObjectSomeValuesFrom(SOMA:hasTerminalScene SOMA:Scene)) SubClassOf(SOMA:StateTransition ObjectSomeValuesFrom( )) SubClassOf(SOMA:StateTransition ObjectSomeValuesFrom( SOMA:ImageSchemaTheory)) -# Class: (Support theory) +# Class: SOMA:SupportTheory (Support theory) AnnotationAssertion(rdfs:comment SOMA:SupportTheory "An image schematic theory that describes the reified functional relation holding between two spatial objects x and y, such that x physically supports y in the presence of gravity; x and y need not be in contact. An example of such an expression is \"The bowl is on the table\". diff --git a/owl/SOMA-STATE.owl b/owl/SOMA-STATE.owl index 32aba4f2..71529a10 100644 --- a/owl/SOMA-STATE.owl +++ b/owl/SOMA-STATE.owl @@ -62,7 +62,7 @@ Declaration(ObjectProperty( (has state type) +# Object Property: SOMA:hasStateType (has state type) AnnotationAssertion(rdfs:comment SOMA:hasStateType "A relation between roles and state types, e.g. 'the chair is the supporter of the person sitting on it'.") AnnotationAssertion(rdfs:label SOMA:hasStateType "has state type") @@ -71,7 +71,7 @@ InverseObjectProperties(SOMA:hasStateType SOMA:isStateTypeOf) ObjectPropertyDomain(SOMA:hasStateType ) ObjectPropertyRange(SOMA:hasStateType SOMA:StateType) -# Object Property: (is state type of) +# Object Property: SOMA:isStateTypeOf (is state type of) AnnotationAssertion(rdfs:comment SOMA:isStateTypeOf "A relation between roles and state types, e.g. 'the chair is the supporter of the person sitting on it'.") AnnotationAssertion(rdfs:label SOMA:isStateTypeOf "is state type of") @@ -85,14 +85,14 @@ ObjectPropertyRange(SOMA:isStateTypeOf (Containment state) +# Class: :ContainmentState (Containment state) AnnotationAssertion(rdfs:comment :ContainmentState "Classifies States in which an object is kept inside another object.") AnnotationAssertion(rdfs:label :ContainmentState "Containment state"@en) SubClassOf(:ContainmentState SOMA:FunctionalControl) SubClassOf(:ContainmentState ObjectSomeValuesFrom(SOMA:isStateTypeOf ObjectIntersectionOf(SOMA:Container ObjectAllValuesFrom( ObjectSomeValuesFrom(SOMA:hasDisposition SOMA:Containment))))) -# Class: () +# Class: SOMA:Configuration (SOMA:Configuration) AnnotationAssertion(rdfs:comment SOMA:Configuration "A description of a State. This includes e.g. what acceptable regions for participant objects of the State might look like. A configuration of the world is construed to be stable on its own. Outside disturbances may cause state transitions, and the settling into some other, self-stable configuration. @@ -105,18 +105,18 @@ The second issue relates to what is \"outside\". The state is a configuration of SubClassOf(SOMA:Configuration ) SubClassOf(SOMA:Configuration ObjectSomeValuesFrom( SOMA:StateType)) -# Class: (Contact state) +# Class: SOMA:ContactState (Contact state) AnnotationAssertion(rdfs:comment SOMA:ContactState "Classifies States in which some objects are in contact.") AnnotationAssertion(rdfs:label SOMA:ContactState "Contact state"@en) SubClassOf(SOMA:ContactState SOMA:StateType) SubClassOf(SOMA:ContactState ObjectAllValuesFrom( ObjectMinCardinality(2 ))) -# Class: () +# Class: SOMA:Containment (SOMA:Containment) AnnotationAssertion(rdfs:comment SOMA:Containment "Classifies States in which an object is placed inside another.") -# Class: (Functional state) +# Class: SOMA:FunctionalControl (Functional state) AnnotationAssertion(rdfs:comment SOMA:FunctionalControl "Classifies States in which an object restricts the movement of another, at least partially. Usually neither object is construed to be an agent. @@ -126,14 +126,14 @@ SubClassOf(SOMA:FunctionalControl SOMA:StateType) SubClassOf(SOMA:FunctionalControl ObjectSomeValuesFrom(SOMA:isStateTypeOf SOMA:Item)) SubClassOf(SOMA:FunctionalControl ObjectSomeValuesFrom(SOMA:isStateTypeOf SOMA:Restrictor)) -# Class: (Linkage state) +# Class: SOMA:LinkageState (Linkage state) AnnotationAssertion(rdfs:comment SOMA:LinkageState "Classifies States in which two objects are in a rigid connection, such that the movement of one determines the movement of the other.") AnnotationAssertion(rdfs:label SOMA:LinkageState "Linkage state"@en) SubClassOf(SOMA:LinkageState SOMA:StateType) SubClassOf(SOMA:LinkageState ObjectSomeValuesFrom(SOMA:isStateTypeOf SOMA:LinkedObject)) -# Class: (Physical accessibility) +# Class: SOMA:PhysicalAccessibility (Physical accessibility) AnnotationAssertion(rdfs:comment SOMA:PhysicalAccessibility "Classifies States in which an item is placed in a container or protected by a protector, but the placement of the item and container is such that a, usually agentive, accessor may nevertheless reach the item in order to perform a task.") AnnotationAssertion(rdfs:label SOMA:PhysicalAccessibility "Physical accessibility"@en) @@ -141,7 +141,7 @@ SubClassOf(SOMA:PhysicalAccessibility SOMA:StateType) SubClassOf(SOMA:PhysicalAccessibility ObjectSomeValuesFrom(SOMA:isStateTypeOf SOMA:Item)) SubClassOf(SOMA:PhysicalAccessibility ObjectSomeValuesFrom(SOMA:isStateTypeOf SOMA:Restrictor)) -# Class: (Physical blockage) +# Class: SOMA:PhysicalBlockage (Physical blockage) AnnotationAssertion(rdfs:comment SOMA:PhysicalBlockage "Classifies States in which an object, in general called restrictor, blocks access to an item. A usually agentive accessor, whose access is blocked, may be specified.") AnnotationAssertion(rdfs:label SOMA:PhysicalBlockage "Physical blockage"@en) @@ -149,20 +149,20 @@ SubClassOf(SOMA:PhysicalBlockage SOMA:StateType) SubClassOf(SOMA:PhysicalBlockage ObjectSomeValuesFrom(SOMA:isStateTypeOf SOMA:Item)) SubClassOf(SOMA:PhysicalBlockage ObjectSomeValuesFrom(SOMA:isStateTypeOf SOMA:Restrictor)) -# Class: (Physical Existince) +# Class: SOMA:PhysicalExistence (Physical Existince) AnnotationAssertion(rdfs:comment SOMA:PhysicalExistence "A State in which an Entity is said to exist in the physical world.") AnnotationAssertion(rdfs:label SOMA:PhysicalExistence "Physical Existince"@en) SubClassOf(SOMA:PhysicalExistence SOMA:PhysicalState) -# Class: (Physical state) +# Class: SOMA:PhysicalState (Physical state) AnnotationAssertion(rdfs:comment SOMA:PhysicalState "A State describing how Entities in the physical world relate to each other.") AnnotationAssertion(rdfs:label SOMA:PhysicalState "Physical state") SubClassOf(SOMA:PhysicalState SOMA:State) SubClassOf(SOMA:PhysicalState ObjectSomeValuesFrom( )) -# Class: (Social state) +# Class: SOMA:SocialState (Social state) AnnotationAssertion(rdfs:comment SOMA:SocialState "A State which describes how Agents relate to each other. @@ -174,7 +174,7 @@ AnnotationAssertion(rdfs:label SOMA:SocialState "Social state") SubClassOf(SOMA:SocialState SOMA:State) SubClassOf(SOMA:SocialState ObjectSomeValuesFrom( )) -# Class: (State type) +# Class: SOMA:StateType (State type) AnnotationAssertion(rdfs:comment SOMA:StateType "An EventType that classifies States.") AnnotationAssertion(rdfs:label SOMA:StateType "State type"@en) @@ -182,7 +182,7 @@ SubClassOf(SOMA:StateType SOMA:State)) SubClassOf(SOMA:StateType ObjectAllValuesFrom( SOMA:StateType)) -# Class: (Support state) +# Class: SOMA:SupportState (Support state) AnnotationAssertion(rdfs:comment SOMA:SupportState "Classifies States in which an object is not able to move under gravity because of its placement relative to some other object.") AnnotationAssertion(rdfs:label SOMA:SupportState "Support state"@en) diff --git a/owl/SOMA-WF.owl b/owl/SOMA-WF.owl index 42d42b9c..580a743b 100755 --- a/owl/SOMA-WF.owl +++ b/owl/SOMA-WF.owl @@ -61,7 +61,7 @@ Declaration(NamedIndividual(SOMA:FailWFUninterpretableTask)) # Object Properties ############################ -# Object Property: (has previous step) +# Object Property: :hasPreviousStep (has previous step) AnnotationAssertion(rdfs:comment :hasPreviousStep "An ordering relation between tasks in some workflow, stating that a task is preceded by another.") AnnotationAssertion(rdfs:label :hasPreviousStep "has previous step") @@ -70,7 +70,7 @@ InverseObjectProperties(:hasPreviousStep SOMA:hasNextStep) ObjectPropertyDomain(:hasPreviousStep ) ObjectPropertyRange(:hasPreviousStep ) -# Object Property: (is first step of) +# Object Property: :isFirstStepOf (is first step of) AnnotationAssertion(rdfs:comment :isFirstStepOf "A relation stating that some task is the first one in a workflow.") AnnotationAssertion(rdfs:label :isFirstStepOf "is first step of") @@ -79,7 +79,7 @@ InverseObjectProperties(:isFirstStepOf SOMA:hasFirstStep) ObjectPropertyDomain(:isFirstStepOf ) ObjectPropertyRange(:isFirstStepOf ) -# Object Property: (is step of) +# Object Property: :isStepOf (is step of) AnnotationAssertion(rdfs:comment :isStepOf "A relation stating that a task is a step in a workflow.") AnnotationAssertion(rdfs:label :isStepOf "is step of") @@ -88,7 +88,7 @@ InverseObjectProperties(:isStepOf SOMA:hasStep) ObjectPropertyDomain(:isStepOf ) ObjectPropertyRange(:isStepOf ) -# Object Property: () +# Object Property: SOMA:definesInput (SOMA:definesInput) AnnotationAssertion(rdfs:comment SOMA:definesInput "The defined participant is an \"input\": @@ -98,7 +98,7 @@ SubObjectPropertyOf(SOMA:definesInput SOMA:definesParticipant) ObjectPropertyDomain(SOMA:definesInput ) ObjectPropertyRange(SOMA:definesInput ObjectUnionOf( )) -# Object Property: () +# Object Property: SOMA:definesOutput (SOMA:definesOutput) AnnotationAssertion(rdfs:comment SOMA:definesOutput "Defines an \"output\" participant: @@ -108,7 +108,7 @@ SubObjectPropertyOf(SOMA:definesOutput SOMA:definesParticipant) ObjectPropertyDomain(SOMA:definesOutput ) ObjectPropertyRange(SOMA:definesOutput ObjectUnionOf( )) -# Object Property: () +# Object Property: SOMA:definesParticipant (SOMA:definesParticipant) AnnotationAssertion(rdfs:comment SOMA:definesParticipant "A Description definesParticipant a Concept to classify participants in Events associated to that Description. @@ -117,7 +117,7 @@ SubObjectPropertyOf(SOMA:definesParticipant ) ObjectPropertyRange(SOMA:definesParticipant ) -# Object Property: (has binding) +# Object Property: SOMA:hasBinding (has binding) AnnotationAssertion(rdfs:comment SOMA:hasBinding "Asserts that in a context described by Description, a Binding relation holds.") AnnotationAssertion(rdfs:label SOMA:hasBinding "has binding"@en) @@ -125,7 +125,7 @@ SubObjectPropertyOf(SOMA:hasBinding ) ObjectPropertyRange(SOMA:hasBinding SOMA:Binding) -# Object Property: (has binding filler) +# Object Property: SOMA:hasBindingFiller (has binding filler) AnnotationAssertion(rdfs:comment SOMA:hasBindingFiller "Indicates that an Entity is described by a Binding, in that it is associated with the Role/Parameter that the Binding binds it to. The Binding is only valid in some descriptive context such as a Workflow or Narrative. @@ -137,7 +137,7 @@ SubObjectPropertyOf(SOMA:hasBindingFiller ) -# Object Property: (has binding role) +# Object Property: SOMA:hasBindingRole (has binding role) AnnotationAssertion(rdfs:comment SOMA:hasBindingRole "Indicates that a Role/Parameter is going to be associated to some filler, or other Role/Parameter, by a Binding. The Binding is only valid in some descriptive context such as a Narrative or Workflow.") AnnotationAssertion(rdfs:label SOMA:hasBindingRole "has binding role"@en) @@ -145,7 +145,7 @@ SubObjectPropertyOf(SOMA:hasBindingRole )) -# Object Property: (has first step) +# Object Property: SOMA:hasFirstStep (has first step) AnnotationAssertion(rdfs:comment SOMA:hasFirstStep "A relation from a Workflow to its first Task.") AnnotationAssertion(rdfs:label SOMA:hasFirstStep "has first step") @@ -153,7 +153,7 @@ SubObjectPropertyOf(SOMA:hasFirstStep SOMA:hasStep) ObjectPropertyDomain(SOMA:hasFirstStep ) ObjectPropertyRange(SOMA:hasFirstStep ) -# Object Property: (has next step) +# Object Property: SOMA:hasNextStep (has next step) AnnotationAssertion(rdfs:comment SOMA:hasNextStep "An ordering relation between tasks in a workflow, saying that a task is followed by another.") AnnotationAssertion(rdfs:label SOMA:hasNextStep "has next step") @@ -161,7 +161,7 @@ SubObjectPropertyOf(SOMA:hasNextStep ) ObjectPropertyRange(SOMA:hasNextStep ) -# Object Property: (has predecessor) +# Object Property: SOMA:hasPredecessor (has predecessor) AnnotationAssertion(rdfs:comment SOMA:hasPredecessor "Indicates that a Task is the predecessor in a Succedence Relation; that is, this is the task to execute first.") AnnotationAssertion(rdfs:label SOMA:hasPredecessor "has predecessor"@en) @@ -169,7 +169,7 @@ SubObjectPropertyOf(SOMA:hasPredecessor ) -# Object Property: (has step) +# Object Property: SOMA:hasStep (has step) AnnotationAssertion(rdfs:comment SOMA:hasStep "A relation between a Workflow and a Task it contains.") AnnotationAssertion(rdfs:label SOMA:hasStep "has step") @@ -177,7 +177,7 @@ SubObjectPropertyOf(SOMA:hasStep ) ObjectPropertyRange(SOMA:hasStep ) -# Object Property: (has succedence) +# Object Property: SOMA:hasSuccedence (has succedence) AnnotationAssertion(rdfs:comment SOMA:hasSuccedence "A relation between a Workflow and a Succedence that appears in it.") AnnotationAssertion(rdfs:label SOMA:hasSuccedence "has succedence"@en) @@ -185,7 +185,7 @@ SubObjectPropertyOf(SOMA:hasSuccedence ) ObjectPropertyRange(SOMA:hasSuccedence SOMA:Succedence) -# Object Property: (has successor) +# Object Property: SOMA:hasSuccessor (has successor) AnnotationAssertion(rdfs:comment SOMA:hasSuccessor "Indicates that a Task is the successor in a Succedence Relation: that is, it is the Task to execute last.") AnnotationAssertion(rdfs:label SOMA:hasSuccessor "has successor"@en) @@ -193,7 +193,7 @@ SubObjectPropertyOf(SOMA:hasSuccessor ) -# Object Property: (has task) +# Object Property: SOMA:hasTask (has task) AnnotationAssertion(rdfs:comment SOMA:hasTask "A relation to indicate that a Task is part of a Workflow or ordering Relation: that is, the task may be executed during the execution of the Workflow, or there exists some Relation between the Tasks that informs how their executions are to be located in time.") AnnotationAssertion(rdfs:label SOMA:hasTask "has task"@en) @@ -206,7 +206,7 @@ ObjectPropertyRange(SOMA:hasTask () +# Data Property: SOMA:hasPriority (SOMA:hasPriority) AnnotationAssertion(rdfs:comment SOMA:hasPriority "A relation asserting some entity has a particular priority.") SubDataPropertyOf(SOMA:hasPriority ) @@ -218,7 +218,7 @@ DataPropertyDomain(SOMA:hasPriority () +# Class: SOMA:Binding (SOMA:Binding) AnnotationAssertion(rdfs:comment SOMA:Binding "A Relation between Roles/Parameters and their fillers that holds in a particular descriptive context, such as a Workflow or Narrative. @@ -243,7 +243,7 @@ SubClassOf(SOMA:Binding ObjectSomeValuesFrom(ObjectInverseOf(SOMA:hasBinding) )) SubClassOf(SOMA:Binding ObjectExactCardinality(1 SOMA:hasBindingRole ObjectUnionOf( ))) -# Class: (Conditional succedence) +# Class: SOMA:ConditionalSuccedence (Conditional succedence) AnnotationAssertion(rdfs:comment SOMA:ConditionalSuccedence "A relation that holds between two OGPTasks that belong to the same OGPWorkflow, and which means that, if a condition is met, the successor task invocation is to be executed after the predecessor task invocation completes. @@ -255,7 +255,7 @@ AnnotationAssertion(rdfs:label SOMA:ConditionalSuccedence "Conditional succedenc SubClassOf(SOMA:ConditionalSuccedence SOMA:Succedence) SubClassOf(SOMA:ConditionalSuccedence ObjectAllValuesFrom(SOMA:hasBinding SOMA:CounterfactualBinding)) -# Class: (Counterfactual binding) +# Class: SOMA:CounterfactualBinding (Counterfactual binding) AnnotationAssertion(rdfs:comment SOMA:CounterfactualBinding "CounterfactualBindings are used to express conditions: @@ -267,7 +267,7 @@ AnnotationAssertion(rdfs:label SOMA:CounterfactualBinding "Counterfactual bindin SubClassOf(SOMA:CounterfactualBinding SOMA:Binding) DisjointClasses(SOMA:CounterfactualBinding SOMA:FactualBinding) -# Class: (Factial binding) +# Class: SOMA:FactualBinding (Factial binding) AnnotationAssertion(rdfs:comment SOMA:FactualBinding "FactualBindings are used in a workflow to assert that: @@ -276,26 +276,26 @@ AnnotationAssertion(rdfs:comment SOMA:FactualBinding "FactualBindings are used i AnnotationAssertion(rdfs:label SOMA:FactualBinding "Factial binding"@en) SubClassOf(SOMA:FactualBinding SOMA:Binding) -# Class: (Role filler binding) +# Class: SOMA:RoleFillerBinding (Role filler binding) AnnotationAssertion(rdfs:comment SOMA:RoleFillerBinding "A binding that connects a role to a particular filler.") AnnotationAssertion(rdfs:label SOMA:RoleFillerBinding "Role filler binding"@en) SubClassOf(SOMA:RoleFillerBinding SOMA:Binding) DisjointClasses(SOMA:RoleFillerBinding SOMA:RoleRoleBinding) -# Class: (Role role binding) +# Class: SOMA:RoleRoleBinding (Role role binding) AnnotationAssertion(rdfs:comment SOMA:RoleRoleBinding "A binding that asserts that two roles have the same filler.") AnnotationAssertion(rdfs:label SOMA:RoleRoleBinding "Role role binding"@en) SubClassOf(SOMA:RoleRoleBinding SOMA:Binding) SubClassOf(SOMA:RoleRoleBinding ObjectAllValuesFrom(SOMA:hasBindingFiller ObjectUnionOf( ))) -# Class: () +# Class: SOMA:StatusFailure (SOMA:StatusFailure) AnnotationAssertion(rdfs:comment SOMA:StatusFailure "A status indicating the failure during some workflow execution.") SubClassOf(SOMA:StatusFailure ) -# Class: () +# Class: SOMA:Succedence (SOMA:Succedence) AnnotationAssertion(rdfs:comment SOMA:Succedence "A relation that holds in some descriptive context such as a Workflow, between two TaskInvocations belonging to that same Workflow. It means that one task invocation should follow the other. @@ -310,7 +310,7 @@ SubClassOf(SOMA:Succedence ObjectSomeValuesFrom(ObjectInverseOf(SOMA:hasSucceden SubClassOf(SOMA:Succedence ObjectExactCardinality(1 SOMA:hasPredecessor SOMA:TaskInvocation)) SubClassOf(SOMA:Succedence ObjectExactCardinality(1 SOMA:hasSuccessor SOMA:TaskInvocation)) -# Class: (Task invocation) +# Class: SOMA:TaskInvocation (Task invocation) AnnotationAssertion(rdfs:comment SOMA:TaskInvocation "An elementary workflow consisting in the invocation of one single task. It is used as a descriptive context inside of which factual bindings are valid between the task's arguments and other entities (such as the \"local variables\" of a larger workflow).") AnnotationAssertion(rdfs:label SOMA:TaskInvocation "Task invocation"@en) @@ -323,17 +323,17 @@ SubClassOf(SOMA:TaskInvocation ObjectExactCardinality(1 () +# Individual: SOMA:FailWFNoContinuation (SOMA:FailWFNoContinuation) AnnotationAssertion(rdfs:comment SOMA:FailWFNoContinuation "A particular kind of failure: the workflow fails because there is no way to continue it, and the normal exit has not been reached.") ClassAssertion(SOMA:StatusFailure SOMA:FailWFNoContinuation) -# Individual: () +# Individual: SOMA:FailWFNondeterministicContinuation (SOMA:FailWFNondeterministicContinuation) AnnotationAssertion(rdfs:comment SOMA:FailWFNondeterministicContinuation "A particular kind of failure: it is not clear how to continue a workflow because several possibilities exist.") ClassAssertion(SOMA:StatusFailure SOMA:FailWFNondeterministicContinuation) -# Individual: () +# Individual: SOMA:FailWFUninterpretableTask (SOMA:FailWFUninterpretableTask) AnnotationAssertion(rdfs:comment SOMA:FailWFUninterpretableTask "A particular kind of failure: a task is not recognized and not associated to anything that could execute it, nor to a workflow that could detail its structure into simpler structure.") ClassAssertion(SOMA:StatusFailure SOMA:FailWFUninterpretableTask) diff --git a/owl/SOMA.owl b/owl/SOMA.owl index f8076bec..68bc4491 100644 --- a/owl/SOMA.owl +++ b/owl/SOMA.owl @@ -35,26 +35,33 @@ Declaration(Class(SOMA:Masterful)) Declaration(Class(SOMA:MedicalDiagnosis)) Declaration(Class(SOMA:RecordedEpisode)) Declaration(Class(SOMA:Reification)) +Declaration(Class(SOMA:Scene)) Declaration(Class(SOMA:Sluggishness)) Declaration(Class(SOMA:SoftwareDiagnosis)) Declaration(Class(SOMA:State)) +Declaration(Class(SOMA:StateTransition)) Declaration(Class(SOMA:Status)) Declaration(Class(SOMA:SuccessDiagnosis)) Declaration(Class(SOMA:Successfulness)) Declaration(Class(SOMA:TechnicalDiagnosis)) Declaration(Class(SOMA:Threshold)) Declaration(Class(SOMA:Unsuccessfulness)) +Declaration(ObjectProperty()) +Declaration(ObjectProperty()) Declaration(ObjectProperty(SOMA:after)) Declaration(ObjectProperty(SOMA:before)) Declaration(ObjectProperty(SOMA:causesTransition)) Declaration(ObjectProperty(SOMA:coOccurs)) Declaration(ObjectProperty(SOMA:contains)) Declaration(ObjectProperty(SOMA:containsEvent)) +Declaration(ObjectProperty(SOMA:derivedFrom)) +Declaration(ObjectProperty(SOMA:directlyDerivedFrom)) Declaration(ObjectProperty(SOMA:during)) Declaration(ObjectProperty(SOMA:finishedBy)) Declaration(ObjectProperty(SOMA:finishes)) Declaration(ObjectProperty(SOMA:firstMember)) Declaration(ObjectProperty(SOMA:hasGoal)) +Declaration(ObjectProperty(SOMA:hasInitialScene)) Declaration(ObjectProperty(SOMA:hasInitialState)) Declaration(ObjectProperty(SOMA:hasInputParameter)) Declaration(ObjectProperty(SOMA:hasOutputParameter)) @@ -62,6 +69,7 @@ Declaration(ObjectProperty(SOMA:hasPhase)) Declaration(ObjectProperty(SOMA:hasPhysicalComponent)) Declaration(ObjectProperty(SOMA:hasSoftwareAgent)) Declaration(ObjectProperty(SOMA:hasStatus)) +Declaration(ObjectProperty(SOMA:hasTerminalScene)) Declaration(ObjectProperty(SOMA:hasTerminalState)) Declaration(ObjectProperty(SOMA:includesConcept)) Declaration(ObjectProperty(SOMA:includesRecord)) @@ -72,6 +80,7 @@ Declaration(ObjectProperty(SOMA:isArtifactInvolvedIn)) Declaration(ObjectProperty(SOMA:isCausedByEvent)) Declaration(ObjectProperty(SOMA:isConceptIncludedIn)) Declaration(ObjectProperty(SOMA:isContainedIn)) +Declaration(ObjectProperty(SOMA:isDirectSourceFor)) Declaration(ObjectProperty(SOMA:isInitialStateOf)) Declaration(ObjectProperty(SOMA:isInputParameterFor)) Declaration(ObjectProperty(SOMA:isInputRoleOf)) @@ -83,6 +92,7 @@ Declaration(ObjectProperty(SOMA:isPlaceInvolvedIn)) Declaration(ObjectProperty(SOMA:isPlanFor)) Declaration(ObjectProperty(SOMA:isRecordIncludedBy)) Declaration(ObjectProperty(SOMA:isSituationIncludedIn)) +Declaration(ObjectProperty(SOMA:isSourceFor)) Declaration(ObjectProperty(SOMA:isTaskOfInputRole)) Declaration(ObjectProperty(SOMA:isTaskOfOutputRole)) Declaration(ObjectProperty(SOMA:isTerminalStateOf)) @@ -148,6 +158,24 @@ AnnotationPropertyRange(SOMA:symbol xsd:string) # Object Properties ############################ +# Object Property: (is initial scene of) + +AnnotationAssertion(rdfs:comment "A relation between StateTransitions and Scenes, which identifies the scene the transition starts from.") +AnnotationAssertion(rdfs:label "is initial scene of") +SubObjectPropertyOf( SOMA:isInitialStateOf) +InverseObjectProperties( SOMA:hasInitialScene) +ObjectPropertyDomain( SOMA:Scene) +ObjectPropertyRange( SOMA:StateTransition) + +# Object Property: (is terminal scene of) + +AnnotationAssertion(rdfs:comment "A relation between StateTransitions and Scenes, which identifies the scene the transition is expected to end at.") +AnnotationAssertion(rdfs:label "is terminal scene of") +SubObjectPropertyOf( SOMA:isTerminalStateOf) +InverseObjectProperties( SOMA:hasTerminalScene) +ObjectPropertyDomain( SOMA:Scene) +ObjectPropertyRange( SOMA:StateTransition) + # Object Property: SOMA:after (SOMA:after) AnnotationAssertion(SOMA:symbol SOMA:after ">") @@ -207,6 +235,23 @@ TransitiveObjectProperty(SOMA:containsEvent) ObjectPropertyDomain(SOMA:containsEvent ) ObjectPropertyRange(SOMA:containsEvent ) +# Object Property: SOMA:derivedFrom (derived from) + +AnnotationAssertion(rdfs:comment SOMA:derivedFrom "The (transitive) relation between an information object and another which it has been derived from.") +AnnotationAssertion(rdfs:label SOMA:derivedFrom "derived from") +SubObjectPropertyOf(SOMA:derivedFrom ) +InverseObjectProperties(SOMA:derivedFrom SOMA:isSourceFor) +TransitiveObjectProperty(SOMA:derivedFrom) +ObjectPropertyDomain(SOMA:derivedFrom ) +ObjectPropertyRange(SOMA:derivedFrom ) + +# Object Property: SOMA:directlyDerivedFrom (directly derived from) + +AnnotationAssertion(rdfs:comment SOMA:directlyDerivedFrom "The relation between an information object and another which it has been derived from.") +AnnotationAssertion(rdfs:label SOMA:directlyDerivedFrom "directly derived from") +SubObjectPropertyOf(SOMA:directlyDerivedFrom SOMA:derivedFrom) +InverseObjectProperties(SOMA:directlyDerivedFrom SOMA:isDirectSourceFor) + # Object Property: SOMA:during (SOMA:during) AnnotationAssertion(SOMA:symbol SOMA:during "d") @@ -253,6 +298,16 @@ SubObjectPropertyOf(SOMA:hasGoal ) ObjectPropertyRange(SOMA:hasGoal ) +# Object Property: SOMA:hasInitialScene (has initial scene) + +AnnotationAssertion(rdfs:comment SOMA:hasInitialScene "A relation between StateTransitions and Scenes, which identifies the scene the transition starts from.") +AnnotationAssertion(rdfs:label SOMA:hasInitialScene "has initial scene") +SubObjectPropertyOf(SOMA:hasInitialScene SOMA:hasInitialState) +AsymmetricObjectProperty(SOMA:hasInitialScene) +IrreflexiveObjectProperty(SOMA:hasInitialScene) +ObjectPropertyDomain(SOMA:hasInitialScene SOMA:StateTransition) +ObjectPropertyRange(SOMA:hasInitialScene SOMA:Scene) + # Object Property: SOMA:hasInitialState (has initial state) AnnotationAssertion(rdfs:comment SOMA:hasInitialState "A relation which connects a Transition to the Situation it starts from.") @@ -311,6 +366,16 @@ AnnotationAssertion(rdfs:comment SOMA:hasStatus "A relation from an Entity to a AnnotationAssertion(rdfs:label SOMA:hasStatus "has status") SubObjectPropertyOf(SOMA:hasStatus ) +# Object Property: SOMA:hasTerminalScene (has terminal scene) + +AnnotationAssertion(rdfs:comment SOMA:hasTerminalScene "A relation between StateTransitions and Scenes, which identifies the scene the transition is expected to end at.") +AnnotationAssertion(rdfs:label SOMA:hasTerminalScene "has terminal scene") +SubObjectPropertyOf(SOMA:hasTerminalScene SOMA:hasTerminalState) +AsymmetricObjectProperty(SOMA:hasTerminalScene) +IrreflexiveObjectProperty(SOMA:hasTerminalScene) +ObjectPropertyDomain(SOMA:hasTerminalScene SOMA:StateTransition) +ObjectPropertyRange(SOMA:hasTerminalScene SOMA:Scene) + # Object Property: SOMA:hasTerminalState (has terminal state) AnnotationAssertion(rdfs:comment SOMA:hasTerminalState "A relation from a Transition to the Situation it ends in.") @@ -396,6 +461,12 @@ SubObjectPropertyOf(SOMA:isContainedIn ) ObjectPropertyRange(SOMA:isContainedIn ) +# Object Property: SOMA:isDirectSourceFor (is direct source for) + +AnnotationAssertion(rdfs:comment SOMA:isDirectSourceFor "The (transitive) relation between an information object and another which was derived from the former.") +AnnotationAssertion(rdfs:label SOMA:isDirectSourceFor "is direct source for") +SubObjectPropertyOf(SOMA:isDirectSourceFor SOMA:isSourceFor) + # Object Property: SOMA:isInitialStateOf (is initial state of) AnnotationAssertion(rdfs:comment SOMA:isInitialStateOf "A relation recording that a Situation was where a Transition began.") @@ -489,6 +560,13 @@ SubObjectPropertyOf(SOMA:isSituationIncludedIn ) ObjectPropertyRange(SOMA:isSituationIncludedIn ) +# Object Property: SOMA:isSourceFor (is source for) + +AnnotationAssertion(rdfs:comment SOMA:isSourceFor "The (transitive) relation between an information object and another which was derived from the former.") +AnnotationAssertion(rdfs:label SOMA:isSourceFor "is source for") +SubObjectPropertyOf(SOMA:isSourceFor ) +TransitiveObjectProperty(SOMA:isSourceFor) + # Object Property: SOMA:isTaskOfInputRole (is task of input role) AnnotationAssertion(rdfs:comment SOMA:isTaskOfInputRole "A relation between a Task and one of its input roles.") @@ -849,6 +927,11 @@ For stative events, the mereological sum of two instances has the same type as b The difference between states and processes is that states are, in addition, homeomeric, and processes are not. This means that, when considering time slices of an event, for states, these time slices always have the same type as the state, but for processes this is not the case.") SubClassOf(SOMA:State ) +# Class: SOMA:StateTransition (State transition) + +SubClassOf(SOMA:StateTransition ObjectSomeValuesFrom(SOMA:hasInitialScene SOMA:Scene)) +SubClassOf(SOMA:StateTransition ObjectSomeValuesFrom(SOMA:hasTerminalScene SOMA:Scene)) + # Class: SOMA:Status (SOMA:Status) AnnotationAssertion(rdfs:comment SOMA:Status "A role that can be played by some parameter which indicates the state of affairs of some entity, e.g. a flag describing the outcome of an action in terms of success or failure, or an indicator of whether a device is turned on or off.") diff --git a/owl/catalog-v001.xml b/owl/catalog-v001.xml index 2b7b20cf..d064982d 100644 --- a/owl/catalog-v001.xml +++ b/owl/catalog-v001.xml @@ -7,7 +7,7 @@ - +