Drammar: a comprehensive ontology of drama
type: Ontology
type: NamedIndividual
type: Vocabulary
version IRI: http://www.purl.org/drammar/0.9
preferred namespace prefix: drammar
modified: 2018-06-11
label: Drammar
description: Designed with the goals to describe and encode the core dramatic qualities and to serve as a knowledge base underlying a number of applications, Drammar is a comprehensive ontology of drama, realized through a collaboration of computer scientists and drama scholars. It makes the knowledge about drama available as a vocabulary for the linked interchange of drama encodings and readily usable by automatic reasoners. By avoinding references to style and artistic qualities Drammar aims at representing the elements shared by different, cross-media manifestations of drama, the soâcalled intangible elements of drama as an intangible cultural heritage form.
date: 2018-03-01
contributor: Carmi Terzulli
contributor: Mario Cataldi
creator: Vincenzo Lombardo
creator: Antonio Pizzo
creator: Rossana Damiano
license: Attribution-NoDerivatives 4.0 International (CC BY-ND 4.0)
rights: Ontology Drammar is available at the url http://purl.org/drammar, under the license Attribution-NoDerivatives 4.0 International (CC BY-ND 4.0). The canonical citation for Drammar is "Vincenzo Lombardo, Rossana Damiano, Antonio Pizzo. Drammar: a comprehensive ontology of drama (2018). http://purl.org/drammar"
issued: 2018-06-11
version info: 0.9
preferred namespace uri: http://www.purl.org/drammar#
publisher: Centro Interdipartimentale di Ricerca per la Multimedialità e l'Audiovisivo - Interdeparmental Center for Research on Multimedia and Audivideo (www.cirma.unito.it)

achieves
type: ObjectProperty
type: FunctionalProperty
sub property of: topObjectProperty
inverse of: isAchievedBy
comment: achieves links a Plan to the Goal it aims at achieving

appraisingAgent
type: ObjectProperty
domain: Emotion
range: Agent
comment: The appraisingAgent property connects an Emotion with the Agent who appraises it. It encompasses specific subproperties for the specific emotion types (in OCC theory, there are 22 emotion types such as Love or Shame)

coOccurInScene
type: ObjectProperty
type: SymmetricProperty
domain: Plan
range: Plan
comment: coOccurInScene can be used to describe the fact that two Plans co-occur in the same Scene.

containsFirstOLE
type: ObjectProperty
sub property of: containsOLE
domain: List
range: OrderedListElement
comment: First OLE of a List.

containsLastOLE
type: ObjectProperty
sub property of: containsOLE
domain: List
range: OrderedListElement
comment: Last OLE of a List.

containsOLE
type: ObjectProperty
type: InverseFunctionalProperty
sub property of: olo:slot
sub property of: hasADTComponent
inverse of: isOleContained
domain: List
range: OrderedListElement
comment: Inverse of isOLElementOf. Connects the ordered list to its elements.

containsTN
type: ObjectProperty
sub property of: hasADTComponent
domain: Tree
range: TreeNode
comment: Connects the tree to its (tree) nodes. E.g., the drama is a tree and the scenes are its tree nodes.

describes
type: ObjectProperty
inverse of: isDescribedBy
domain: SituationSchema
range: DramaPerdurant
comment: A SituationSchema describes a DramaPerdurant, i.e. provides a template for describing processes and states.

feels
type: ObjectProperty
sub property of: hasMentalState
inverse of: isEmotionOf

follows
type: ObjectProperty
sub property of: olo:next
sub property of: topObjectProperty
inverse of: precedes
comment: Inverse of precedes. Sequential order in an ordered list.

HappyFor_appraisingAgent
type: ObjectProperty
sub property of: appraisingAgent
domain: Emotion
range: Agent

happyFor_target
type: ObjectProperty
sub property of: target
domain: Emotion
range: Agent

hasADTComponent
type: ObjectProperty
domain: AbstractDataType
range: ADTComponent
comment: A generic property for representing the relation among a given abstract structure type and its components.

hasChild
type: ObjectProperty
sub property of: hasADTComponent
inverse of: hasParent
domain: TreeNode
range: TreeNode
comment: the basic relation employed for modelling the computational data structure of tree.

hasData
type: ObjectProperty
type: FunctionalProperty
sub property of: olo:item
inverse of: isDataOf
domain: ADTComponent
range: Thing
comment: Property that connects a structural element (e.g. of the class OLE) with the data contained in it. Range is not defined; it is defined for each specific structure element.

hasDoneState
type: ObjectProperty
sub property of: topObjectProperty
inverse of: isDoneStateOf

hasEmotionType
type: ObjectProperty
sub property of: topObjectProperty
domain: EmotionSchema
range: ExternalRefEmotionType

hasExtRef
type: ObjectProperty
type: FunctionalProperty
inverse of: isExtRefOf
domain: Class
  union of: DescriptionTemplate
  union of: DramaEntity
range: ExternalReference
comment: Quality of an entity (DramaEndurant) In particular: Object_type This property provides a URI, in YAGOSUMO or in Wordnet, or a custom string that defines the class of some object. E.g., object individual PinkOctopus in Oktapodi is of Object_type "octopus" in Yago. Environment_periodOfYear Epoch of some environment. E.g. summer, january, Easter. Can be a URI or forced custom string. This is why Range is empty. Environment_location Can be "exterior" or "interior". From a fixed menu. Environment_timeOfDay Can be "dawn" "morning" "afternoon" "evening" "night". From a fixed menu. Environment_type The type of an envrironment. E.g.: forest, kitchen, office, ... . It can be custom string or URI. This is why Range is empty. Environment_epoch Epoch of some environment. E.g. 20th century, 1710's, 50's. Can be a URI or forced custom string. This is why Range is empty.

hasFiller
type: ObjectProperty
type: FunctionalProperty
inverse of: isFillerOf
domain: Role
range: DramaEntity
comment: Filler is the property that connects a Role of a FrameNetSchema with the DramaEntity (DramaEndurant or DramaPerdurant) that fills that Role.

hasGoal
type: ObjectProperty
sub property of: hasMentalState
inverse of: isGoalOf
domain: Agent
range: Goal
comment: The property which connects an agent with her/his goals.

hasMember
type: ObjectProperty
sub property of: hasADTComponent
inverse of: isMemberOf
domain: Set
range: SetMember
comment: The specific property for modelling Sets (as a data structure). Any entity, in Drammar, can be a member of a Set.

hasMentalState
type: ObjectProperty
domain: Agent
range: MentalState

hasMotivationIn
type: ObjectProperty
inverse of: isMotivationFor
comment: The hasMotivation property represents the relation bewteen a plan and the timeline it motivates (namely, where the actions of the plan are actually contained).

hasParent
type: ObjectProperty
type: FunctionalProperty
comment: The parent/child relation for modelling tree structures.

hasPlanEffect
type: ObjectProperty
type: FunctionalProperty
sub property of: topObjectProperty
inverse of: isPlanEffectOf
domain: Plan
range: ConsistentStateSet
comment: Property that connects a plan with the consistent set of states that is the effect of a plan (ConsistentStateSet).

hasPlanPrecondition
type: ObjectProperty
type: FunctionalProperty
sub property of: topObjectProperty
inverse of: isPlanPreconditionOf
domain: Plan
range: ConsistentStateSet
comment: Property that connect a plan with the ConsistentStateState which forms its precondition.

hasPropositionalContent
type: ObjectProperty
type: FunctionalProperty
inverse of: isPropositionalContentOf
domain: Class
  union of: BeliefSchema
  union of: GoalSchema
comment: hasPropositionalContent links a BeliefSchema or a GoalSchema to the its content (a factual state or process), that is, the Process or State that is the actual content of the belief or the goal.

hasRole
type: ObjectProperty
type: InverseFunctionalProperty
inverse of: isRoleOf
domain: FrameNetSchema
range: Role
comment: Connects a SituationSchema ( modelled by a frame-like linguistic structure) with each Role of the schema.

hasRoot
type: ObjectProperty
sub property of: containsTN
domain: Tree
range: TreeNode
comment: Connects the Tree with the TreeNode that is its Root.

hasTimelineEffect
type: ObjectProperty
type: FunctionalProperty
type: InverseFunctionalProperty
sub property of: topObjectProperty
inverse of: isTimelineEffectOf
domain: Timeline
range: ConsistentStateSet
comment: Property that connect a Timeline with the ConsistentStateState which forms its effects.

hasTimelinePrecondition
type: ObjectProperty
type: FunctionalProperty
sub property of: topObjectProperty
inverse of: isTimelinePreconditionOf
domain: Timeline
range: ConsistentStateSet
comment: Property that connect a Timeline with the ConsistentStateState which forms its precondition.

hasValueEngaged
type: ObjectProperty
sub property of: hasMentalState
inverse of: isValueEngagedOf
domain: Agent
range: Value
comment: The property hasValue connects an agent to her/his values

hingesOn
type: ObjectProperty
type: InverseFunctionalProperty
inverse of: isHingedOnBy
domain: DrammarScene
range: ConflictSet
comment: A DrammarScene hinges on some ConflictSet

inConflictWith
type: ObjectProperty
type: SymmetricProperty
domain: Plan
range: Plan
comment: The conflict relation over plans. The ontology is neutral with respect with conflicts over other entity types, such a goals: it only assumes that conflicts over plans are observable.

inSupportOf
type: ObjectProperty
sub property of: topObjectProperty
domain: Plan
range: Plan
comment: The support relation over goals (parallel to inConflictWith)

intends
type: ObjectProperty
sub property of: topObjectProperty
inverse of: isIntendedBy
domain: Agent
range: Plan
comment: Intends has as domain an Agent and as range a Plan.

isAchievedBy
type: ObjectProperty
sub property of: topObjectProperty
domain: Goal
range: Plan
comment: This property connects a goal with the plan that achieves it.

isDataOf
type: ObjectProperty
comment: isDataOf connects some entity to a data structure component (namely, an OrderedListElement) of which it is the content.

isDescribedBy
type: ObjectProperty
type: FunctionalProperty
sub property of: topObjectProperty
comment: Inverse of describes, this property connects a Dynamics (Process or State) with the SituationSchema that describes it.

isDoneStateOf
type: ObjectProperty
type: FunctionalProperty
range: Class
  union of: Plan
  union of: Process
comment: This is the property that connects a process with a particular state, called a done state, that holds whether the process has terminated.

isEmotionOf
type: ObjectProperty
type: FunctionalProperty
sub property of: isMentalStateOf
domain: Emotion
range: Agent
comment: Connects an emotion with the agent who feels it.

isExtRefOf
type: ObjectProperty

isExtRefRoleOfExtRefSchema
type: ObjectProperty
domain: ExternalRefRole
range: ExternalRefSchema
property chain axiom: isExtRefOf
property chain axiom: isRoleOf
property chain axiom: hasExtRef
comment: This property chain serves the purpose of connecting a frame role with the frame it belongs to, via the following property chain: isExtRefOf o isRoleOf o hasExtRef where - isExtRefOf connects ExtRefRole to Role - isRoleOf connects Role to ProcessSchema - hasExtRef connects ProcessSchema to ExtRefSchema (remember that the actual reference to the frame or frame role in an external resources are dealt with by attaching a "quale" data property to the classes that represent the external references)

isFillerOf
type: ObjectProperty
type: InverseFunctionalProperty
sub property of: topObjectProperty
comment: Connects some DramaEndurant or Perdurant to a Role in a SituationSchema

isGoalOf
type: ObjectProperty
sub property of: isMentalStateOf
range: Agent
comment: inverse of hasGoal

isHingedOnBy
type: ObjectProperty
comment: Inverse of hingesOn.

isIntendedBy
type: ObjectProperty
type: FunctionalProperty
sub property of: topObjectProperty
comment: Inverse of intends.

isKnownBy
type: ObjectProperty
sub property of: isMentalStateOf
inverse of: knows
range: Agent

isMemberOf
type: ObjectProperty
sub property of: topObjectProperty

isMentalStateOf
type: ObjectProperty

isMotivationFor
type: ObjectProperty
type: FunctionalProperty
domain: Plan
range: Timeline
comment: A plan is the motivation for a timeline, namely for a list of units containing actions. This property is functional: so, a plan can motivate only a timeline. Notice that this implies that a plan cannot motivate the same timeline motivated by a sub-plan, and that a plan cannot motivate the same timeline motivated by a more abstract plan. Of course, the fact that this property is functional does not imply that a single timeline cannot be motivated by more plans.

isOleContained
type: ObjectProperty
type: FunctionalProperty
sub property of: topObjectProperty
comment: Connects the element of an ordered list to the ordered list.

isOrderedBy
type: ObjectProperty
inverse of: orders

isPlanEffectOf
type: ObjectProperty
sub property of: topObjectProperty

isPlanPreconditionOf
type: ObjectProperty
sub property of: topObjectProperty

isPropositionalContentOf
type: ObjectProperty
comment: Inverse of hasPropositionalContent. It links a BeliefSchema or a GoalSchema to a State or Process.

isRoleOf
type: ObjectProperty
sub property of: topObjectProperty

isSpannedBy
type: ObjectProperty
type: FunctionalProperty
type: InverseFunctionalProperty
sub property of: topObjectProperty
inverse of: spans

isTimelineEffectOf
type: ObjectProperty
type: FunctionalProperty
type: InverseFunctionalProperty
sub property of: topObjectProperty

isTimelinePreconditionOf
type: ObjectProperty
sub property of: topObjectProperty

isValueEngagedOf
type: ObjectProperty
type: FunctionalProperty
sub property of: isMentalStateOf
range: Agent

knows
type: ObjectProperty
sub property of: hasMentalState
domain: Agent
range: Belief
comment: Property of an agent, who BELIEVES a Belief (a mental state with a propositional content). BELIEVES = KNOWS.

love_appraisingAgent
type: ObjectProperty
sub property of: appraisingAgent
domain: Emotion
range: Agent

love_target
type: ObjectProperty
sub property of: target
domain: Emotion
range: Agent

orders
type: ObjectProperty
domain: Timeline
range: Unit
comment: A Timeline orders Unit.

precedes
type: ObjectProperty
sub property of: olo:previous
domain: OrderedListElement
range: OrderedListElement
comment: Sequential order in an ordered list.

shame_appraisingAgent
type: ObjectProperty
sub property of: appraisingAgent
domain: Emotion
range: Agent

shame_target
type: ObjectProperty
sub property of: target
domain: Emotion
range: Agent

spans
type: ObjectProperty
type: FunctionalProperty
type: InverseFunctionalProperty
sub property of: topObjectProperty
domain: Scene
range: Timeline
comment: The coincidence relation of a Scene on a Timeline.

target
type: ObjectProperty
comment: A generic property for describing the relation of an appraised emotional state with the target of the emotion, further articulated into more specific target types for each emotion type (see appraisingAgent property).

Goal_type
type: DatatypeProperty
domain: Goal
range: Datatype
  one of: Achievement
  one of: Maintenance
  one of: Perform
  one of: Query
comment: Type of the goal: one of the strings "Achievement" "Maintainance" "Perform" "Query"

Schema_type
type: DatatypeProperty
sub property of: topDataProperty
domain: SituationSchema
range: Datatype
  one of: belief
  one of: emotion
  one of: framenet
  one of: goal
  one of: value
comment: This datatype property represents the type of schema for some construct. Its value correspond to the different types of state acknowledged in Drammar : beliefs, goals, etc. Each value correspond to a state type: e.g., "belief" for the Belief class. In particular, framenet is the magic word for the schemata extracted from Framenet.

accomplished
type: DatatypeProperty
sub property of: topDataProperty
domain: Class
  union of: AbstractPlan
  union of: DirectlyExecutablePlan
range: boolean
comment: Accomplished = true stands for entirely executed and goal achieved Accomplished = false stands for entirely executed and goal not achieved When missing, nothing is said about execution.

atStake
type: DatatypeProperty
domain: Value
range: boolean
comment: Boolean property of a Value: - true, if the value is at stake; - false, if the value is balanced.

hasManifestation
type: DatatypeProperty
type: FunctionalProperty
domain: Unit
range: anyURI
comment: hasManifestation This property connects a Unit to a manifestation of drama according to FRBR model. In the real world, a manifestation is represented by a IRI (e.g., the URL of a movie, of the recording of a performance, or of the digital edition of a novel).

hasMessage
type: DatatypeProperty
domain: Thing
range: string
comment: Anything can convey a message. Standard cases: Signpost at a city entrance "Ciudad de Mexico"; Toothpaste brand name on the object toothpaste: "Colgate" A specific utterance in a communication action.

isIntentional
type: DatatypeProperty
type: FunctionalProperty
domain: Process
range: boolean
comment: Boolean property for Intentionality of processes. Applies to Processes to distinguish Action from an UnintentionalProcess.

originalTerm
type: DatatypeProperty
sub property of: topDataProperty
domain: ExternalReference
range: string
comment: This is the string originally inserted for searching the URI in the external ontology. E.g. "parlare" "eleganza"

quale
type: DatatypeProperty
domain: ExternalReference
comment: Any quality associated to anything. Its range is a string (if a URI is needed to resolve the reference, this is dealt with when processing the annotation) All its subproperties are introduced on the basis of some specific annotation task. So, its current subproperties refer to FrameNet, VerbNet, YagoSumo, MWN corpora, respectively.

quale_MWNSense
type: DatatypeProperty
sub property of: quale

quale_YAGOSUMOConcept
type: DatatypeProperty
sub property of: quale
domain: ExternalReference
comment: The range is a concept in YagoSUMO. E.g. &%Speaking+, &%Arriving=, these two probably from SUMO; http://www.mpii.de/yago/resource/wordnet_bathing_100427853, probably from YAGO.

quale_framenetFrame
type: DatatypeProperty
sub property of: quale
domain: ExternalRefSchema
comment: This property of the ExternalRefSchema links the schema to the frame it corresponds to, needed to describe some state or process occurring in drama. The value is the ID in Framenet. Currently, in the implementation, it is the string of the number of choice in the list of frames returned. E.g. "1"

quale_framenetRoleID
type: DatatypeProperty
sub property of: quale
domain: ExternalRefRole
comment: Role_framenetRoleID ID of the role as stated by Framenet. It is the string returned through the access to Framenet. The string represent the ID of the Frame Element.

quale_verbnetRoleLabel
type: DatatypeProperty
sub property of: quale
domain: ExternalRefRole
comment: Type of the role as stated by Verbnet. It is the string returned through the access to Verbnet. This happens when the access to Framenet fails.

topDataProperty
type: DatatypeProperty
comment: All these properties are data associated with classes. Labels are self-explaining (e.g., isIntentional) or have Thing as domain. In non-obvious names, the domain class is in the prefix of the name (e.g. Goal_type).

ADTComponent
type: Class
subclass of: DataStructure
comment: ADTComponent This class includes the entities which provide the components of abstract data types. Currently, only the list data type includes a component, the OrderedListElement. The mapping on the AbstractDataType class is given by the hasADTComponent object property, which has the AbstractDataType class as its domain, and the ADTComponent class as its range.

AbstractDataType
type: Class
subclass of: DataStructure
comment: AbstractDataType The data types needed for describing drama are sets, lists and trees (more precisely, tree nodes).

AbstractPlan
type: Class
equivalent class: Class
  intersection of: Plan
  intersection of: Restriction
    on property: achieves
    some values from: Goal
  intersection of: Restriction
    on property: containsOLE
    some values from: Class
      intersection of: OrderedListElement
      intersection of: Restriction
        on property: hasData
        some values from: Plan
  intersection of: Restriction
    on property: isMotivationFor
    some values from: Timeline
subclass of: Plan
comment: Abstract Plan An abstract plan is a recursive plan, i.e., a plan whose elements are plans. Formally, an AbstractPlan is a list (List class) containing (containsOLE) elements (OrderedListElements) that have plans as their data (hasData). The plans contained in an abstract plan can be either abstract plans or directly executable plans.

Action
type: Class
equivalent class: Class
  intersection of: Process
  intersection of: Restriction
    on property: isDataOf
    some values from: Class
      intersection of: SetMember
      intersection of: Restriction
        on property: isMemberOf
        some values from: Unit
  intersection of: Restriction
    on property: isIntentional
    has value: true
subclass of: Process
disjoint with: UnintentionalProcess
comment: An Action is an intentional Process, which is a type of Process. Formally, an action is an Process which is constrained to be contained (isMemberOf) some Unit. In Drammar, an Action can be part of a plan of an agent (formally, a plan ia a list of actions), or can be included in a Unit (ordered into some timeline). Only direct executable plans (DirectlyExecutablePlan class) contain actions The Action class is formally disjoint with the UnintentionalEventiveProcess class. We have introduced an explicit boolean datatype property isIntentional, because it could be that the annotators will use actions directly in the units (i.e. without explicitly introducing a plan for it).

Agent
type: Class
equivalent class: Class
  intersection of: DramaEndurant
  intersection of: Restriction
    on property: intends
    some values from: Plan
subclass of: DramaEndurant
disjoint with: Object
comment: Agent. Derived from BDI model, a mentalist model of agent which sees the agent as a rational entity who form intentions, or plans, (based on her beliefs) to achieve her desires (or goals). See Bratman et al. 1988 and Cohen and Levesque 1995. Agents are those entities in drama, that potentially - have goals (object property hasGoal); - intend plans to achieve goals (object property intends); - participate in actions with some role (object property isFillerOf); In addition, agents have emotional states (as a result of targeted emotions appraisal processes) and have moral values (hasValue): - feel emotions as a result of a cognitive appraisal process (specific object properties link each the appraisal of each emotion type to the agent); - have values (object property hasValue); The requirement, in drama, is that an agent has a plan, since the fact of having a goal would not be sufficient to ensure that the goal is translated into some concrete, perceivable behavior in drama. Having a plan, instead, implies that the agent also has goal. Notice that some Agent (e.g. Polonius) is involved in an action without being intentional (e.g., being the topic of a conversation), it remains classified as an Agent in Drammar, though it fills a different role in the frame (e.g., Topic of Conversation). References: Bratman, M. E., Israel, D. J., & Pollack, M. E. (1988). Plans and resourceâbounded practical reasoning. Computational intelligence, 4(3), 349-355. Cohen, P. R., & Levesque, H. J. (1995, June). Communicative Actions for Artificial Agents. In ICMAS (Vol. 95, pp. 65-72).

Belief
type: Class
equivalent class: Class
  intersection of: MentalState
  intersection of: Restriction
    on property: isKnownBy
    some values from: Agent
  intersection of: Restriction
    on property: isDescribedBy
    qualified cardinality: 1
    on class: BeliefSchema
  intersection of: Restriction
    on property: isKnownBy
    qualified cardinality: 1
    on class: Agent
subclass of: MentalState
disjoint with: Goal
comment: A belief is what an agent believes (which may be true or not in the world) In the BDI model, beliefs form the agent's knowledge about the world that the agent relies on for devising plans to achieve her goals. In Drammar there is no distinction between knowing and believing, because reasoning concerns the agent motivations for acting, rather than the relationship between single agent knowledge and shared knowledge. A belief is formally defined as the type of MentalState described by a BeliefSchema. In the annotation, it is in the scope a ConsistenStateSet, that is precondition or effect of a Plan. SWRL rules for mapping project a belief onto some ConsistentStateSet which precedes or follows a timeline.

BeliefSchema
type: Class
equivalent class: Class
  intersection of: MentalStateSchema
  intersection of: Restriction
    on property: Schema_type
    has value: belief
subclass of: MentalStateSchema
comment: The BeliefSchema class describes a Belief (a type of MentalState). This class is formally defined as the subclass of MentalStateSchema having as its quale_schemaType value the string "belief". A BeliefSchema has as its propositional content (via the propositionalContent object property) a factual process (FactualProcess class) or state (FactualState class).

ConflictSet
type: Class
equivalent class: Class
  intersection of: Set
  intersection of: Restriction
    on property: hasMember
    some values from: Class
      intersection of: SetMember
      intersection of: Restriction
        on property: hasData
        some values from: Plan
subclass of: Set
comment: This class represents the relation of conflict distributed over a set of plans. It represents the orchestration of conflicts in drama. Although conflict may occur, in drama, between (or within) entities of different types (characters may be in conflict with each other, ir the same character may experience conflicting emotions), here we reduce the notion of conflict to this single class.

ConsistentStateSet
type: Class
equivalent class: Class
  intersection of: Set
  intersection of: Class
    union of: Restriction
      on property: isPlanEffectOf
      qualified cardinality: 1
      on class: Plan
    union of: Restriction
      on property: isPlanPreconditionOf
      qualified cardinality: 1
      on class: Plan
    union of: Restriction
      on property: isTimelineEffectOf
      qualified cardinality: 1
      on class: Timeline
    union of: Restriction
      on property: isTimelinePreconditionOf
      qualified cardinality: 1
      on class: Timeline
  intersection of: Restriction
    on property: hasMember
    some values from: Class
      intersection of: SetMember
      intersection of: Restriction
        on property: hasData
        some values from: State
comment: A ConsistentStateSet is a set of states held consistent by definition. It can be a set of states bordering a timeline (i.e., the state of affairs holding before and after the timeline) or it can be the state of affairs that holds before and after a plan (in this case, it represents the plan precondintions and effects). The isTimelinePreconditionOf (isTimelineEffectOf) property connects a ConsistentStateSet with a Timeline. The isPlanPreconditionOf (isPlanEffectOf) property connects a ConsistentStateSet with a Plan. A ConsistentStateSet has one or more states as its members (hasMember property)

DataStructure
type: Class
comment: DataStructure This class encodes the data structures that provide structural organization to the other entities. It includes abstract data types (namely sets, lists and trees) and data type components.

DescriptionTemplate
type: Class
disjoint with: DramaEntity
comment: DescriptionTemplate This class contains a well known role-based pattern for representing the linguistic schemata that describe the elements of drama, such as the entities and dynamics. Drammar imports this pattern from other ontologies, namely DOLCE. The class DescriptionTemplate contains two classes: - Role - SituationSchema The class SituationSchema provides the specific pattern for the description of incidents and states, generically termed here as "situations". A situation can be either a process or a state, usually described by a linguistic expression consisting of a verb ("giving") for processes, such as in the expression "Ophelia gives the gift back to Hamlet", or a by a preposition ("behind") for states, such as in the expression "Polonius is behind the tapestry"). The Role class provides the pattern for the roles that play a part in the state or process (in the above example, the role of the "donor" filled by Ophelia, the role of the "recipient" filled by Hamlet, etc.). The linguistic counterpart of the role-based structure of the description templates is provided by a frame-like accounts of the linguistic descriptions of events, such as Framenet or Verbnet (https://framenet2.icsi.berkeley.edu/fnReports/data/frameIndex.xml). Based on a lexical semantics perspective, these initiatives are aimed at grouping verbs (including statives) into "frames of action", i.e., linguistic structures representing a group of semantically similar verbs with the complements that accompany them. Following a design choice that characterizes the Drammar ontology, all references to the external (linguistic or commonsense) knowledge are mediated by the ExternalReference class, a top level class whose function is specifically to act as a bridge to the external knowledge (see the documentation of the class). So, neither the Roles nor the Situation Schemata directly refer to the external linguistic knowledge they assume: rather, the hasExtRef property links each component of the patte…

DirectlyExecutablePlan
type: Class
equivalent class: Class
  intersection of: Plan
  intersection of: Restriction
    on property: achieves
    some values from: Goal
  intersection of: Restriction
    on property: containsOLE
    some values from: Class
      intersection of: OrderedListElement
      intersection of: Restriction
        on property: hasData
        some values from: Action
  intersection of: Restriction
    on property: isMotivationFor
    some values from: Timeline
subclass of: Plan
comment: DirectlyExecutablePlans Directly executable plans are plans that contain only actions. Formally, a directly executale plan is a list (List class) that contains (containsOLE) only elements (OrderedListElement) that have actions as their data (hasData).

DramaEndurant
type: Class
subclass of: endurant
subclass of: DramaEntity
comment: DramaEndurant is an entity of drama that can be described as an endurant following Gangemi et al. 2002. In Gangemi et al. 2002 "Endurants are wholly present (i.e., all their proper parts are present) at any time they are present", differently from perdurants, which are only partially present at any time they are present. Endurants (and Perdurants, in some cases) play a role in processes and states: an Endurant is connected to a role (Role class) in the description of a given process or state by the hasRole object property. The class of drama endurants encompasses more specific drama entities such as Agent and Object. This bipartite distinction is derived from the drama literature, where - Agents that intentionally perform actions; - Objects are involved in the actions in an unintentional way. For instance, in Hamlet, the King of England is a drama endurant (but non an agent) because it is the filler of a role in Claudius' actions (sending ... ) but does not intend any plan (a feature would locate it in the Agent class). The difference beteween the King of England and a coffee machine is entrusted to common sense knowlegde (e.g., the external lexical knowledge stating the sementic type of these two entities). Reference: Gangemi, A., Guarino, N., Masolo, C., Oltramari, A., & Schneider, L. (2002). Sweetening ontologies with DOLCE. In Knowledge engineering and knowledge management: Ontologies and the semantic Web (pp. 166-181). Springer Berlin Heidelberg.

DramaEntity
type: Class
comment: DramaEntity Class of all the dramatic entities, that is, of all the entities that are peculiar to drama. Its sisters are classes that are not peculiar to drama, but concern templates, (DescriptionTemplate), references to external lexical and semantic systems (ExternalReference) and data structures (DataStructure) from computer science.

DramaPerdurant
type: Class
subclass of: perdurant
subclass of: DramaEntity
subclass of: Restriction
  on property: isDescribedBy
  qualified cardinality: 1
  on class: SituationSchema
comment: The DramaPerdurant class contains the entities of drama that can described as perdurants in DOLCE (Gangemi et al. 2002): "Perdurants [...] just extend in time by accumulating different temporal parts, so that, at any time they are present, they are only partially present, in the sense that some of their proper temporal parts (e.g., their previous or future phases) may be not present." In other words, perdurants, namaly processes, are not entirely present at any time they are present, differently from endurants. The DramaEdurant is the class of elements of Drama that describe the story dynamics, i.e. Processes and States. In the context of Drammar, the individuals of this class describe the story advancement in terms of incidents and states holding between incidents. Each has a specific relation to the segmentation of drama: processes are grouped in units, states precedes and follows timelines (which contain units). Notice that processes and states are not distinct in Framenet, the knowledge source we refer to for describing perdurants outside of Drammar. Reference: Gangemi, A., Guarino, N., Masolo, C., Oltramari, A., & Schneider, L. (2002). Sweetening ontologies with DOLCE. In Knowledge engineering and knowledge management: Ontologies and the semantic Web (pp. 166-181). Springer Berlin Heidelberg.

DrammarScene
type: Class
equivalent class: Class
  intersection of: Scene
  intersection of: Restriction
    on property: hingesOn
    some values from: ConflictSet
subclass of: Scene
comment: DrammarScene A DrammarScene is a type of scene that hinges on characters' conflicting plans. In Drammar, the conflict over plans is represented by a class, the ConflictSet, which contains the set of plans in conflict. The hingesOn object property connects the DrammarScene with the Conflict Set.

Emotion
type: Class
equivalent class: Class
  intersection of: MentalState
  intersection of: Restriction
    on property: isDescribedBy
    qualified cardinality: 1
    on class: EmotionSchema
comment: Emotion is the class of emotions felt by an agent in a scene. Formally, it is described as the subclass of MentalState described by an EmotionSchema. The emotions refer to OCC emotion ontology (22 emotions types). Emotion type is an external resource (ExternalRefEmotionType). An Emotion has an appraising agent (appraisingAgent object property) and, when appraised, is an emotion of (isEmotionOf object property) that agent. An emotion also has a target (the agent or object that is the target of the emotion): a specifi object property connects each emotion type with its target (e.g., shame_target, love_target, etc.).

EmotionSchema
type: Class
equivalent class: Class
  intersection of: MentalStateSchema
  intersection of: Restriction
    on property: Schema_type
    has value: emotion
subclass of: MentalStateSchema
comment: An EmotionSchema represents the description of an EmotionState, bridged onto some external linguistic or semantic system through the mediation of the ExternalRefEmotionType class. The EmotionSchema is a MentalStateSchema for describing an Emotion. Formally, it is constrained to the value "emotion" for the quale_schemaType data property. The hasExtRef property links the EmotionSchema to the ExternalRefEmotionType class which in turn links the description of the Emotion to a reference theory of emotions.

ExternalRefEmotionType
type: Class
subclass of: ExternalReference
comment: This class includes individuals for all the 22 emotion types referred by OCC theory. The individuals are bridge individuals to some external formal OCC-based knowledge source, which does not exist yet but is assumed here. These individuals could also be a bridge to some commonsense ontology, such as YagoSumo for Values, but it would be different from the adoption of the OCC theory, as committed in Drammar.

ExternalRefEntity
type: Class
subclass of: ExternalReference
comment: The ExternalRefEntity class has the function of bridging the description of a DramaEntity (not an entity in general) to some external linguistic or semantic resource such a dictionary or an ontology. An entity can be linked to its ExternalReference by the hasExtRef object property, which has the ExternalReference as its range. The ExternalRefEntity iherits the "quale" data property from its direct ancestor, ExternalReference class.

ExternalRefRole
type: Class
subclass of: ExternalReference
comment: The ExternalRefRole class has the function of bridging the description of a Role (not an entity in general) to a description of the role in some external linguistic that represents the argument structure of an event. An Role can be linked to its ExternalRefRole by the hasExtRef object property, which has the ExternalRefRole as its range. The ExternalRefRole class has three data properties which connect it to the reference system: - role_framenetRoleID: connects the Role to the id of the corresponding role in FrameNet - role_verbnetRoleType: connects the Role to the name of the corresponding role in VerdNet (a string) - role_ID_resource

ExternalRefSchema
type: Class
subclass of: ExternalReference
comment: The ExternalRefSchema class has the function of bridging the description of a SituationSchema to some external lexical-semantic resource representing apt to represent the role structure of a process or state. An SituationSchema (or, better, a subclass of it) can be linked to its ExternalRefSchema by the hasExtRef object property, which has the ExternalReference as its range. The quale_frame_URI data property connects the SituationSchema with the FrameNet frame which correponds to it, following the paradigm of Linked Data.

ExternalReference
type: Class
comment: ExternalReference This is a class that provides the service of accumulating all the "quale" datatype properties that refer to external linguistic or commonsense knowledge sources. Through this class, the description of the drama entities is bridged onto some external lexicon or ontology. Its subclasses are useful in grouping, but do not represent specific issues in support.

FrameNetSchema
type: Class
equivalent class: Class
  intersection of: SituationSchema
  intersection of: Restriction
    on property: Schema_type
    has value: framenet
subclass of: SituationSchema
comment: A FrameNetSchema corresponds to a process or state describable by a frame in Framenet (https://framenet2.icsi.berkeley.edu/fnReports/data/frameIndex.xml). The reference of the schema to the external linguistic reality (the FrameNet frame) is mediated through an apposite class subsumed by the ExternalReference class, the ExternalRefSchema class: the SituationSchema class (and, by inheritance, also the FrameNetSchema class) is linked to the ExternalRefSchema class via the hasExtRef property. The quale_frame_URI, then, bridges the ExternalRefSchema class onto the URI of the appropriate frame.

Goal
type: Class
equivalent class: Class
  intersection of: MentalState
  intersection of: Restriction
    on property: isGoalOf
    some values from: Agent
  intersection of: Restriction
    on property: isDescribedBy
    qualified cardinality: 1
    on class: GoalSchema
  intersection of: Restriction
    on property: isGoalOf
    qualified cardinality: 1
    on class: Agent
subclass of: MentalState
comment: The Goal class represents the objectives of an agent. In the BDI model, the agent is driven by her desires, or goal, and forms plans to achieve them. In Drammar, a goal is achieved by a plan; the achives object property connects a plan with the goal it achieves (a single goal, since the achieves property is functional). An agent intends (intends object property) a goal. Formally, the Goal class is a defined as a subclass of the MentalState class which is constrained: - to be the goal of some agent - to be part of some ConsistentStateState - to be described by a GoalSchema Goal has a propositional content that is - a process in the case of perform goal PG (Hamlet wants to ask Ophelia ...) - a state in the case of - achievement (Hamlet wants Ophelia goes to a nunnery) - maintenance (Hamlet wants Claudius (keeps) believing Hamlet is mad) - query (Hamlet wants to know whether Ophelia is honest) In these various cases the propositional content is different: - Perform Goal - PC: Action - AG - PC: State, embedded in one Belief, with status false or Process, embedded in Belief, with accomplishment false - MG - PC: State or Process, embedded in Belief, with status/accomplishment true - Query Goal - PC: depends on query; e.g.: - Y/N question: the boolean status of a state (currently implemented as a State with status TRUE) - Wh question: the filler of a role in some state or process (currently not implemented) These are guidelines for writing the plans correctly.

GoalSchema
type: Class
equivalent class: Class
  intersection of: MentalStateSchema
  intersection of: Restriction
    on property: Schema_type
    has value: goal
subclass of: MentalStateSchema
comment: The GoalSchema class describes a Goal (a type of MentalState). This class is formally defined as the subclass of MentalStateSchema having as its quale_schemaType value the string "goal". A GoalSchema has as its propositional content (via the propositionalContent object property) a factual process (FactualProcess class) or state (FactualState class).

List
type: Class
subclass of: olo:OrderedList
subclass of: AbstractDataType
subclass of: Restriction
  on property: containsFirstOLE
  all values from: OrderedListElement
subclass of: Restriction
  on property: containsLastOLE
  all values from: OrderedListElement
subclass of: Restriction
  on property: containsOLE
  all values from: OrderedListElement
comment: List List is inspired by a well known ontology (http://smiy.sourceforge.net/olo/spec/orderedlistontology.html#ordered_list); however, its implementation in Drammar makes some simplifications (e.g., indexes are not included) and renames some entities according to the terminology of the drama domain. List in drama: - Plan: sequence of plans (abstract plans) or single actions (directly executable plans); - Timeline: sequence of units.

MentalState
type: Class
equivalent class: Class
  intersection of: State
  intersection of: Restriction
    on property: isDescribedBy
    qualified cardinality: 1
    on class: MentalStateSchema
subclass of: State
comment: MentalStates are EventiveStates that are attributed to the mind of an agent. There are four types of mental states: 1. Emotion 2. Belief 3. Goal 4. Value Belief and Goal are traditionally described as having a propositional content because they both concern some attitude of the agent toward a proposition; in Drammar, we don't enforce this distinction because the reference theoriesd we adopt for emotion and values also enforce some time of propositional content. The only difference is that only the schema types for beliefs and goals (BeliefSchema and GoalSchema) have a propositional content attached to it (through the propositionalContent object property). A MentalState is defined as an EventiveState that is described by a MentalStateSchema. The latter are to be specified as EmotionSchema, BeliefSchema, GoalSchema, ValueSchema, depending on the MentalState type: so, the MentalStateSchema type works as a selector for the right trait of the mental schema.

MentalStateSchema
type: Class
equivalent class: Class
  intersection of: SituationSchema
  intersection of: Restriction
    on property: isMentalStateOf
    some values from: Agent
subclass of: SituationSchema
comment: The MentalStateSchema class collects all the schemata that license the behavior of the mental states. Following the guidelines for describing mental states in Ferrario, R., & Oltramari, A. (2005, March). Towards a computational ontology of mind. In Aerospace Conference, 2005 IEEE (pp. 1-9). IEEE, propositional attitudes such as beliefs and goals are considered mental states in Drammar. The MentalState class includes: - BeliefSchema - EmotionSchema - GoalSchema - ValueSchema The schemata match the mental states included in Drammar. Mental states are grouped in the DramaPerdurant class as eventive mental states (MentalState class) or as factual mental states (F_MentalState class).

Object
type: Class
equivalent class: Class
  intersection of: DramaEndurant
  intersection of: Class
    complement of: Restriction
      on property: intends
      some values from: Plan
subclass of: DramaEndurant
comment: Object Class of entities (endurant) that participates into Perdurants, but without having intentions. An object is formally defined as a subclass of DramaEndurant whose member do not have plans. Objects can be filler of roles in the description of processes and states (for example, a book can be "theme" in a giving action (i.e. the entity that changes ownership as a consequence of a giving act). This class is formally disjoint from Agents (Disjoint property).

OrderedListElement
type: Class
subclass of: olo:Slot
subclass of: ADTComponent
comment: Class of the elements of the ordered lists (lists are plans and timelines). Sometimes referred to as OLE. The hasOrderedListElement object property has the List class as its domain and the OrderedListElement as its range. Notice that this class works as a placeholder that represents the single item in a list (it is not the list content itself): the property hasData links the OrderedListElement with the actual data, i.e. the content of the item. For example, the OrderedListElements Plans have other plans or actions as their data.

Plan
type: Class
equivalent class: Class
  intersection of: List
  intersection of: Restriction
    on property: isIntendedBy
    some values from: Agent
subclass of: List
comment: Plan A plan is a sequence of actions devised by an agent to achieve some Goal. In the BDI model, the agent's 'intention' to execute a plan is the bridge between goals and practical actions. In Drammar, a plan is intended by (intendedBy object property) an Agent to achieve (achieve property) some Goal. As a consequence, the plan motivates (isMotivationFor object property) a timeline (i.e. a given extent of the drama text). These are the necessary and sufficient conditions of class. Following the paradigm of hierarchical planning, plans are recursive. So plans can contains actions or other, simpler plans. Formally, a Plan is a list (namely, it is a subclass of the List class) whose elements are simpler plans (for abstract plans) or actions (for directly executable plans). A plan is related to its elements by the containsOLE property.

Process
type: Class
subclass of: process
subclass of: DramaPerdurant
comment: Processes represents the dynamic class of the perdurants: they are gathered into units, which are contained into ordered timelines bordered by states. Process is the class that bridges to the concept of Process in upper ontologies, externally to Drammar (like DOLCE, where States and Processes are types of Statives: here, we include also the event types called accomplishments and achievements in DOLCE). Consider that such resources are not of linguistic type. The DescriptionTemplate class (or, better, its subclass FrameNetSchema), in fact, drives the behavior of the process inside a Plan or a Unit, linking it (via the ExternalReference Class) to: 1. a Wordnet sense 2. a Frame (from Framenet or Verbnet) 3. a set of Roles, played by roles encompassed in the frame All these links are bridged by the ExternalReference Class, which has "quale" properties that link the reference to specific resources. In the external ontology, a process may be logically defined through the use of axioms: for example, in the action of asking, it is assumed that Speaker and Addressee are connected through some communication medium, e.g. co-presence in a room or a telephone. In Drammar, the DramaStructures that contain the Processes are Units (subclasses of DramaSets) and Plans (subclasses of DramaLists). They are then subdivided through a further trait, that is whether the process is intentional (of an agent) or not (Action or UnintentionalProcess). This trait is defined through a specific Datatype property, of boolean type, called isIntentional. So, its subclasses are: - Action: with isIntentional property valued TRUE; - UnintentionalProcess: with isIntentional property valued FALSE. Same happens in parallel to the States, although in that case the trait concerns the state schema.

Role
type: Class
equivalent class: Class
  intersection of: DescriptionTemplate
  intersection of: Restriction
    on property: hasFiller
    some values from: Class
      union of: DramaEndurant
      union of: DramaPerdurant
  intersection of: Restriction
    on property: isRoleOf
    qualified cardinality: 1
    on class: FrameNetSchema
subclass of: DescriptionTemplate
comment: Role provides the pattern for the role fillers in a frame instantiation, that occurs in SituationSchema, for describing processes and states. A Role is filled by a DramaEntity: the fact that a given role has an entity as a filler is represented by the hasFiller property and its inverse isFillerOf property. A Role belongs (isRoleOf) to a given SituationSchema, namely a ProcessSchema or a StateSchema (hasRole property). The Role class is related to its filler by the hasFiller property, whose range is the DramaEntity class. For example, given the incident describable as "Ophelia gives the gift back to Hamlet", the roles of "donor" (the one who does the action of giving), "recipient" (the one wjho receives the object to be given) and "theme" (the object of giving action) are all instance of the Role class connected to the same Situation, each labeled with a linguistic label ("donor", "recipient", etc.) and each connected to its filler via the hasFiller property. Roles can also be intended as thematic roles of verbs following the description contained in the Verbnet resource (http://verbs.colorado.edu/verb-index/index.php). The Role class, via the hasExtRef object property, is linked to the subclass of the top level ExternalReference class, the ExternalRefRole class, whose function is to connect the description of the role with the appropriate role name or URI in a linguistic account of roles through apposite data properties (namely, the Role_framenetRoleID and Role_verbnetRoleType data properties respectively for FrameNet and VerbNet).

Scene
type: Class
equivalent class: Class
  intersection of: TreeNode
  intersection of: Restriction
    on property: spans
    some values from: Timeline
  intersection of: Restriction
    on property: hasChild
    all values from: Scene
subclass of: TreeNode
comment: Scene Drama is divided into scenes, which correspond to an extent of the 'text' of drama. Scenes (as a type of TreeNode) form a hierarchy, which represents the recursive nature of drama. This is obtained by implementing the Scene class as a subclass of the TreeNode class. Scenes contains children scenes: this relation is modeled through the hasChild property. All scenes span some timeline (spans object property), i.e., they have a correspondance with some extent of the drama text (represented by the Timeline class).

Set
type: Class
subclass of: AbstractDataType
subclass of: Restriction
  on property: hasMember
  all values from: SetMember
comment: Set The class of set structures. The relation between sets and set members is represented by the hasMember object property. It includes specific subclasses, with each subclass characterized by a specific type of members. Sets include: - ConflictsSets: sets of conflicting plans; - ConsistentStateSets: sets of consistent states (left and right boundaries of timelines and plans). - Units: sets of actions.

SetMember
type: Class
subclass of: ADTComponent
comment: Class of the elements of the sets (sets are conflict sets, consistent state sets, and units). Sometimes referred to as SM. The hasMember object property has the Set class as its domain and the SetMember as its range. Notice that this class works as a placeholder that represents the single element in a set (it is not the content itself): the property hasData links the SetMember with the actual data, i.e. the content of the item. For example, the specific Set that is a Unit hasMember some SetMember that hasData some Action.

SituationSchema
type: Class
subclass of: DescriptionTemplate
comment: The situation schema provides the pattern for the description of incidents and states. It is inspired by the Situation ontology Pattern of the Ontology Design Pattern initiative (http://ontologydesignpatterns.org/). So, a SituationSchema describes ("describes" object property) a DramaPerdurant (either a State or a Process). The schema works as a hub for the roles involved in a situation. The property hasRole links the Situation class (its domain) with the Role class (the range of the property). Also, notice that, as illustrated in the documentation of the SituationSchema class, a Situation Schema (or, better, its subclasses) does not directly refer to the external linguistic knowledge employed to describe drama: rather, it refers to the ExternalRefSchema class (subclass of the top level ExternalReference class), which in turn refers to the linguistic knowledge. The SituationSchema class specializes into specific schemata for describing specific type of situations: - FrameNetSchema: for describing processes, like giving or killing (in Drammar, they are grouped into units arranged on timelines), and states, like being behind some object or being dead (in Drammar, they are bundled into sets that border timelines and plans). - MentalStateSchema: this class groups the specific types of schemata for describing the mental states of the agents in Drammar, namely beliefs, goals, emotions and values. Technically, the subtypes of SituationSchema are characterized by different values of the quale_schemaType data property: "belief", "emotion", "framenet", "goal", "value". Finally, it is worth mentioning that is a specific design choice of Drammar not to represent the nesting of states: only the type of the top level state, e.g., a belief, is represented, independent of what that belief contains in turn. This flat style of representation is determined by the decision not to commit to a specific logical account of state types. When Drammar is employed for annotation, the content n…

State
type: Class
equivalent class: Class
  intersection of: DramaPerdurant
  intersection of: Restriction
    on property: isDataOf
    some values from: Class
      intersection of: SetMember
      intersection of: Restriction
        on property: isMemberOf
        some values from: ConsistentStateSet
subclass of: state
subclass of: DramaPerdurant
comment: State represents the static class of the Perdurant. State is the class that bridges to the concept of State in upper ontologies, externally to Drammar. For example, in DOLCE, states and process are the two distinct types of statives. Both factual and eventive states are further divided into different state types: - MentalStates, namely Belief, Goals, Values and Emotions (all sharing some propositional content in their description); - StateOfAffairs, namely situations holding in the world. States participate to some structure. In Drammar, these structures are ConsistenStateSets (types of Sets), which borders timelines and plans. The specific type pf States are defined through the use of specific types of StateSchema (subclass of DescriptionTemplate). So, its subclasses are: - MentalState: the mental state of an agent; - StateOfAffairs: an objective state of the story world.

StateOfAffairs
type: Class
equivalent class: Class
  intersection of: State
  intersection of: Restriction
    on property: isDescribedBy
    qualified cardinality: 1
    on class: FrameNetSchema
subclass of: State
comment: StateofAffairs are states that concern the storyworld as a whole; they are described by a FrameNetSchema, namely a SituationSchema that points (through the ExternalRefSchema class) points to a specific frame. This class gathers all states that are external to the characters' mental states, and can be linguistically described through some external resources such as FrameNet.

Timeline
type: Class
equivalent class: Class
  intersection of: List
  intersection of: Restriction
    on property: hasTimelineEffect
    some values from: ConsistentStateSet
  intersection of: Restriction
    on property: hasTimelinePrecondition
    some values from: ConsistentStateSet
  intersection of: Restriction
    on property: containsOLE
    all values from: Class
      intersection of: OrderedListElement
      intersection of: Restriction
        on property: hasData
        some values from: Unit
comment: Timeline Timeline is a subclass of List whose function is to impose some ordering on the units in a drama. Notice that the notion of timeline cannot be collapsed onto the actual text: rather, it is simply an indexing posed upon units (which correspond to a manifestation of drama in FRBR sense). In formal terms, the orders object property has Timeline as its domain and units as its range, so a unit "orders" some units. A Timeline contains unit. Formally, the elements (OrderedListElements class) contained in a timeline (containsOLE property) are units. A Timeline is surrounded by states of affairs that hold before and after it, namely instances of the ConsistentSateSets class that precede and follow a given timeline. Formally, the Timeline class is the domain of the hasTimelineEffect(Precondition) properties, which have the ConsistentStateSet class as their range. A timeline is motivated by some plan (motivates object property) and is spanned by some unit (span object property). The relation between units and timelines is independent of the scene/timeline relation.

Tree
type: Class
subclass of: AbstractDataType
subclass of: Restriction
  on property: containsTN
  all values from: TreeNode
subclass of: Restriction
  on property: hasRoot
  max qualified cardinality: 1
  on class: TreeNode
comment: Tree The class of tree structures. The relation between trees and tree nodes is represented by the containsTN abd hasRoot object properties. A drama is actually a tree, composed recursively of subtrees, which are scenes at different levels. The subtree relationship is established between scenes (property hasChild), which are actually tree nodes.

TreeNode
type: Class
subclass of: ADTComponent
subclass of: Restriction
  on property: hasChild
  all values from: TreeNode
comment: TreeNode The TreeNode class represents tree-like structures in drama, namely Scenes. This class only represents the recursive structure of drama without an explicit commitment to the notion of 'drama as a tree'.

UnderspecifiedPlan
type: Class
equivalent class: Class
  intersection of: Plan
  intersection of: Class
    complement of: Restriction
      on property: achieves
      some values from: Goal
  intersection of: Class
    complement of: Restriction
      on property: containsOLE
      some values from: OrderedListElement
  intersection of: Class
    complement of: Restriction
      on property: isMotivationFor
      some values from: Timeline
subclass of: Plan
comment: An UnderspecifiedPlan is a plan that is part of a larger plan to achieve some goal, but has not been executed. In drama, it represents the unobservable part of a plan that has not been fully carried out by some agent. Its existence (in the agent's mind) can only be conjectured - remember that a Plan is intended by some agent by definition. As the object of a conjecture, it does not contain any details in the representation of drama (this does not mean that it does not contain them in the agent's mind). As such, an UnderspecifiedPlan: - does *not* motivate a timeline (it has not taken place); - does *not* achieve a goal (the actions/subplans composing it and its specific goal are not known); - does *not* contain any actions. These conditions, part of its definition as an Equivalent Class, distinguish it from Abstract and Directly Executable Plans.

UnintentionalProcess
type: Class
equivalent class: Class
  intersection of: Process
  intersection of: Restriction
    on property: isDataOf
    some values from: Class
      intersection of: SetMember
      intersection of: Restriction
        on property: isMemberOf
        some values from: Unit
  intersection of: Restriction
    on property: isIntentional
    has value: false
subclass of: Process
comment: UnintentionalProcess is an unintentional Process. So, an UnintentionalProcess is a Process with the property isIntentional that values FALSE.

Unit
type: Class
equivalent class: Class
  intersection of: Set
  intersection of: Restriction
    on property: hasMember
    some values from: Class
      intersection of: SetMember
      intersection of: Restriction
        on property: hasData
        some values from: Class
  intersection of: Restriction
    on property: isOrderedBy
    some values from: Timeline
comment: Unit Units are the segmentation of drama. A drama can have multiple segmentations. Units are ordered by some Timeline. Units are devoted to the representation of characters' actions. So, we require that any unit contains at least one action whose description (ProcessSchema) encompasses at least one role having an agent as a filler. If a building collapses, this action, by itself, can be part of Unit only if an agent is involved in it (e.g., an agent dies). This definition guarantees that, in the minimal case, at least one agent appears as filler of the roles in the description of at least an action of every unit. A Unit has one or more actions as its members (hasMember property).

Value
type: Class
equivalent class: Class
  intersection of: MentalState
  intersection of: Class
    union of: Restriction
      on property: atStake
      has value: false
    union of: Restriction
      on property: atStake
      has value: true
  intersection of: Restriction
    on property: isValueEngagedOf
    some values from: Agent
  intersection of: Restriction
    on property: isDescribedBy
    qualified cardinality: 1
    on class: ValueSchema
  intersection of: Restriction
    on property: isValueEngagedOf
    qualified cardinality: 1
    on class: Agent
subclass of: MentalState
comment: The Value Class represents the values of an agent. These values are engaged in drama by the execution of the agents' plans. Formally, a Value is a subclass of the MentalState class which is constrained to: - be in a given state, true or false, of the boolean property atStake - be in a ConsistentStateSet (namely, the consequences of some plan that puts the value at stake or brings it back to balance) - be described by a ValueSchema. For example, in the nunnery scene, Ophelia's answer "At home, my Lord", being a lie, results in a state that puts at stake Hamlet's value of honesty.

ValueSchema
type: Class
equivalent class: Class
  intersection of: MentalStateSchema
  intersection of: Restriction
    on property: Schema_type
    has value: value
subclass of: MentalStateSchema
comment: The ValueSchema class describes an agent's Value. Formally, it is a subclass of MentalStateSchema whose property quale_schemaType is constrained to the string "value".

Thing
type: Class
comment: Thing contains four major taxonomies: - DescriptionTemplate - DramaEntity - ExternalReference - DataStructure

Class
intersection of: Action
intersection of: Restriction
  on property: isDescribedBy
  some values from: Class
    intersection of: FrameNetSchema
    intersection of: Restriction
      on property: hasRole
      min qualified cardinality: 1
      on class: Class
        intersection of: Role
        intersection of: Restriction