]> PR-OWL is an upper ontology to support writing probabilistic ontologies. It is based on Multi-Entity Bayesian Networks (MEBN). More information can be found at www.pr-owl.org. 1.04 Each generic random variable can have many arguments. Arguments are usually restricted in their type and meaning via the context nodes of an MFrag. In order to model these complex N-ary relations, PR-OWL makes use of the ArgRelationship class, which is a reified relation that conveys the number and order of arguments that each RV expects, it's type (defined via a link to the OVariable class), and the link to the RV itself. MEBN logic has the concept of a simple and a composite random variable term. Simple RV terms accepts variables and constant symbols as arguments. Composite RV terms also accepts other RV terms as arguments. In PR-OWL, the class ArgRelashionship models composite RV terms, while its SimpleArgRelashionship subclass models simple RV terms. 1 The BooleanRVStates class is formed by the Boolean truth-value states and are applied to Boolean random variables. Individuals of this class represent the random variables from MEBN logic's built-in MFrags: logical connectives, quantifiers, the equality random variable. Likewise their function in MEBN logic, these individuals allow PR-OWL ontologies to represent a rich family of probability distributions over interpretations of first-order logic. Note that MEBN's built-in Indirect Reference MFrag is already represented in PR-OWL via its recursive scheme of building complex formulas. Nodes represent random variables, which by definition have a list of mutually exclusive, collectively exhaustive states. In PR-OWL, those states are represented by individuals from class Entity. Some random variables have a list of categorical values as its possible states, and these are represented by elements from subclass CategoricalRVStates. The conditional relationship class is a reified property representing a (parent) node and one of its possible states. Individuals of this class are used to built PR-OWL probabilistic distribution tables. Each cell of such a table corresponds to a probability assignment of a possible value of a node given one combination of the states of its parents. Each individual of class CondRelationship represents one parent/state pair, so a probability assigment is conditioned by a set of CondRelationship pairs (one for each parent node). 1 1 In general, MFrags impose constraints to the type of arguments each of its resident RVs should accept. The individuals of the Context class represent these types of constraints. In PR-OWL, the class Context is the only subclass of the Node class that accepts composite RV terms as arguments (that is, uses the complete ArgRelationship instead of the more restricted SimpleArgRelashionship). A context node is either satisfiable or not, which means its possible states are instances of the BooleanRVStates class. 1 A declarative distribution is a distribution that is conveyed via a xsd:string datatype, using a specific format defined in the hasDeclaration datatype property. In order to allow a MEBN algorithm to work, a parser should be able to retrieve the probability distribution information in the format it is stored and then pass that information to the MEBN algorithm in its own proprietaty format. Describing a probability distribution is a much more compact and flexible way of conveying it. However, it assumes that an OWL-P parser would understand the format in which the information is stored. PR-OWL tables, on the other hand, convey probability distributions in a more interoperable way, but are not flexible enough to represent complex distributions such as the cases in which a node has multiple possible parents. For added compatibility, one probability distribution can be stored in multiple formats (i.e. multiple DeclarativeDist individuals for the same RV). 1 1 1 Domain MFrags is the subclass of class MFrag that includes all the domain-specific MFrags. It is disjoint with class Finding_MFrag. All generative MFrags created by the ontology engineer (i.e. the domain expert) are members of this class. This is the subclass of class Resident (node) that includes all domain-specific resident nodes. It is disjoint with classes Finding_res and BuiltInRV. MEBN logic treats the world as being comprised of entities that have attributes and are related to other entities. The logic assumes uniqueness or each concept (i.e. unique name assumption), so each entity in a MEBN model has a unique identifier and no unique identifier can be assigned to more than one entity. PR-OWL follows MEBN syntax and semantics for defining entities so each member of the class Entity has a unique identifier assigned by the datatype property hasUID. OWL doesn't have the unique name assumption so the UID can be seen a tool for providing maximum compatibility with legacy OWL ontologies, since parsers may refer to it as a means to enforce uniqueness among declared entities. It is important to note that not all concepts in an ontology have a UID, but only those which will be considered as part of the probabilistic model that is implicit in any probabilistic ontology. This structure allows mixing legacy deterministic ontologies with probabilististic ones. That allows knowledge engineers to assign PR-OWL definitions only to the parts of the domain for which plausible reasoning is desired. 1 1 Each individual of class Skolem represents a Skolem constant in a MEBN quantifier random variable. Each MEBN quantifier random variable corresponds to a first-order formula beginning with a universal or existential quantifier. The Skolem constant in the MEBN random variable represents a generic individual within the scope of the universal or existential quantifier of the corresponding first-order formula. MEBN logic contains a set of built-in MFrags for quantifier random variables. In PR-OWL modelers can use individuals of class Skolem to define distributions for Skolem constants used in quantifier random variables. Finding MFrags are used to convey information about findings, which is the default way of entering evidence in a MEBN MTheory so a probabilistic algorithm can be applied to perform inferences regarding the new evidence. They have no context nodes, only one input and one resident node. 1 1 1 1 This is the subclass of class Resident (node) that includes all finding nodes. Finding nodes convey new evidence into a probabilistic system via a Finding_MFrag. The class is disjoint with classes Domain_res and BuiltInRV. 0 1 In PR-OWL, an input node is basically a "copy" of a resident node that is used as an input in a given MFrag. Thus, each individual of class Input is linked with an individual of class Resident via the property isInputInstanceOf. 1 1 MEBN Fragments (MFrags) are the basic structure of any MEBN logic model. MFrags represent influences among clusters of related RVs and can portray repeated patters using ordinary variables as placeholders in to which entity identifiers can be substituted. In PR-OWL, each individual the MFrag class represents a MEBN Fragment (MFrag). 1 An MTheory is a collection of MFrags that statisfies consistency constraints ensuring the existence of a unique joint distribution over the random variables mentioned in the MTheory. In PR-OWL, the class MTheory allows a probabilistic ontology to have more than one valid MTheory to represent its RVs, and each individual of that class is basically a list of the MFrags that collectively form that MTheory. In addition, one MFrag can be part of more than one MTheory. The MetaEntity class includes all the entities that convey specific definitions about entities (e.g. typelabels that name the possible types of entities). A node is part of an MFrag and it can be a random variable that is defined within that MFrag (a resident node), a RV that input values to nodes within that MFrag (an input node), or a RV that expresses the context in which the probability distributions within that MFrag are valid (a context node). Ordinary variables are placeholders used in MFrags to refer to non-specific entities as arguments in a given MFrag's RVs. 1 1 The class ObjectEntity aggregates the MEBN entities that are real world concepts of interest in a domain. They are akin to objects in OO models and to frames in frame-based knowledge systems. An PR-OWL table has all the probability assignments for each state of a RV stored in a xsd:decimal format (future implementations might use the pr-owl:prob format, but currently that means incompatibilities with OWL, which has no support for PR-OWL custom datatypes). This format for storing probability distributions cannot represent complex cases for which only formulas can represent a probability distribution (e.g. a node that have a variable number of parents) and usually incurs in huge ontologies, since each table can have many cells and each cell is an individual of the ProbAssign class. Therefore, PR-OWL tables are only recommended for the simplest models in which the maximum level of compatibility is desired. 1 Each cell in an PR-OWL table has a probability assignment for the state of a RV given the states of its parent nodes. Thus, the resulting relationship is N-ary and we opted for representing it via a reified relation (ProbAssign) that includes the name of the state to which the probability is being assigned, the probability value itself, and the list of states of parent nodes (i.e. conditionants) that collectively define the context in which that probability assignment is valid. Also, individuals of the ProbAssign class have an object property that links them with its respective PR-OWL table. 1 1 This class is meant to represent the probability distributions that are defined in an MFrag to each of its resident nodes (random variables). A probability distribution can be described using a proprietary declarative format, such as a Netica table or a Quiddity function, or via an PR-OWL table (which has probability assigments as its cells). Resident nodes are the random variables that have their respective probability distribution defined in the MFrag. 1 Each generic random variable can have many arguments. Arguments are usually restricted in their type and meaning via the context nodes of an MFrag. In order to model these complex N-ary relations, PR-OWL makes use of the SimpleArgRelationship class, which is a reified relation that conveys the number and order of arguments that each RV expects, it's type (defined via a link to the TypeContext class), and the link to the RV itself. 1 This object property links one instance of class ArgRelationship (which is linked to a RV) to an internal variable within the home MFrag where its RV is resident, to a node that is being used as argument in that RV, or to a MEBN entity. This object property is the inverse of isArgTermIn. One individual of the class ArgRelationship can have only one RV (since it refers to a specific argument of an RV), and thus can be related to only one OVariable (Simple RV Terms) or one Node (Composite RV Terms), which makes that property a functional one. The inverse property is isArgTermIn. This object property is the link between a node in an MFrag and the reified relation that conveys its respective arguments. Note that each instance of a node will have only one argument relashionship, which is defined within that node's MFrag. The inverse of this property is isArgumentOf Each instance of the class ProbAssign corresponds to the probability assigment for a given state of a RV. This probability assignment is conditioned by the parent RVs of that RV. This object property conveys the list of the states of the parent RV which have influenced that specific probability assignment. Since any MEBN entity can be a state in a RV, this property has MEBNEntity class as its range. The inverse property is isConditionantOf This object property links a resident node or a built-in RV to its many possible "context node instances", or the instances of context nodes that take their values from that resident node or built-in RV. The inverse property is isContextInstanceOf. This object property links an MFrag to the context nodes being applied to it. The inverse property is isContextIn This object property relates one MFrag with the Exemplar constants (i.e. an individual from class Exemplar) that are defined in that MFrag. The inverse of this property is isExemplarIn. This object property makes the connection between the many possible inner terms inside a MENB equation. It is used to decompose random variable terms usually employed in context and input nodes. The inverse property is isInnerTermOf. This object property links a resident node or a built-in RV to its many possible "input node instances", or the instances of input nodes that take their values from that resident node or built-in RV. The inverse property is isInputInstanceOf. This object property links each MFrag with its respective input nodes. The inverse property is isInputNodeIn This object property links one MTheory with its respective MFrags. Usually, a probabilistic ontology will have only one MTheory as a means to convey the global joint probability distribution of its random variables. However, MEBN logic allows many possible MTheories to represent a given domain, so it is reasonable to infer that in some circunstances it might be preferable to have one probability ontology being represented by more than one MTheory. The inverse property is isMFragOf This object property links one MFrag with its nodes. The inverse property is isNodeFrom This inverse functional object property relates one MFrag to its ordinary variables (i.e. individuals from class OVariable hat are related to this MFrag). The inverse of this property is isOVariableIn. This object property links a resident node of an MFrag with its respective parent(s), which has(have) to be an individual of either the class Resident or the class Input. The inverse property is isParentOf. This object property links a CondRelationship to a Node. The reified conditional relationship is used to build PR-OWL Tables. One table usually has many probability assignments (which correspond to cells in a table), and each probability assignment has a set of conditionants. Conditionants are the states of the parents of a node that form a combination where a given probability assignment holds. Each CondRelationship defines a pair parent/state-of-parent, and the hasParentName property defines the parent name of that pair. This object property links a CondRelationship to an Entity. The reified conditional relationship is used to build PR-OWL Tables. One table usually has many probability assignments (which correspond to cells in a table), and each probability assignment has a set of conditionants. Conditionants are the states of the parents of a node that form a combination where a given probability assignment holds. Each CondRelationship defines a pair parent/state-of-parent, and the hasParentState property defines the parent state of that pair. This object property defines what are the possible values of a node in an MFrag (which is by definition a random variable). Possible states include all kinds of entities. The inverse property is isPossibleValueOf An PR-OWL table is formed by many individual members of the class ProbAssign, which are cells in that table. This object property relates one PR-OWL table to its respective cells (ProbAssign elements). The inverse property is isProbAssignIn. This object property links a RV to its respective probability distributions, as defined in that RV's home MFrags. Note that this property is not being defined as functional, implying a polymorphic version of MEBN (where each RV can have different distributions in different MFrags). The inverse of this property is isProbDistOf. This object property links an MFrag with its respective resident node(s). The inverse property is isResidentNodeIn When a probability distribution is conveyed as an PR-OWL table, each individual cell is represented as an individual of the ProbAssign class. This object property refers to which state of a random variable (i.e. MFrag node) a given probability assignment refers to. The property itself is functional, since one state can have only one probability assignment for the configuration listed in each individual of the ProbAssign class. In the extended MEBN logic that is the backbone of PR-OWL, each and every entity has a type. The list of types consists of the individuals from class MetaEntity. This functional object property defines the type of each entity by linking it to an individual of the MetaEntity class. Every entity has a MetaEntity (TypeLabel, CategoryLabel, Boolean, or a domain-specific label) as a Type. As an example, an hypothetical indivudual of an ObjectEntity class named Starship would have type Starship, which is a domain-specific label for an ObjectEntity individual that happens to be a starship. That domain-specific label is itself an individual of the MetaEntity class. The inverse property is isTypeOf. This object property links an individual of class OVariable, Resident, Entity, or Skolem to one ArgRelationship(s) that has individual as its argument. Each ArgRelationship can have only one argument, but each individual of those classes can refer to many ArgRelationships. The inverse of this property is hasArgTerm. This object property links an Argument Relationship to its respective Node (i.e. to the individual of class Node that has this ArgRelationship into its argument list). The inverse of this property is hasArgument. This object property links one possible state of a parent node to the configuration that is conditioning its children state's probability distribution. The inverse property is hasConditionant. This object property links context node to its "generative resident node" or built-in RV (i.e. the resident node or built-in RV from which the context node is a pointer). The inverse property is hasContextInstance This object property links one context node to the respective MFrag in which that context node applies. The inverse property is hasContext. This object property relates one Skolem constant (i.e. an individual from class Skolem) to the MFrag in which it is defined. The inverse of this property is hasSkolem. This object property is used to model expressions. The inverse property is hasInnerTerm This object property links an input node to its "generative resident node", or the resident node to which that input node is a copy. The inverse property is hasInputInstance. This object property links a node to the MFrags that have it as an input. The inverse property is hasInputNode. This object property links one MFrag to one or more MTheories (i.e. individuals of class MTheory) that have that MFrag as its component. The inverse property is hasMFrag. This general object property links one node to the MFrag it belongs to. The inverse property is hasNode This functional object property relates one ordinary variable (i.e. an individual from class OVariable) to its respective MFrag. The inverse of this property is hasOVariable. This object property links a resident or input node of an MFrag with its respective children, which are resident nodes in that same MFrag. The inverse property is hasParent. This object property correlates one entity with the node(s) of one or more MFrags that have such entity as a possible state. Note that the individuals listed as being possible values of a node must form a mutually exclusive, collectively exhaustive set. PR-OWL has the same tools for enforcing exclusiveness (i.e. MEBN entity unique name assumption and the existential and universal qualifiers acting together as a closure axiom), but the domain expert must ensure completeness. The inverse property is hasPossibleValues. This is the inverse of the hasProbAssign object property and links one individual probability assignment to its respective probability distribution table. This object property links a probability distribution to its respective RV (resident node). Note that this property is functional, since each probability distribution in a MFrag defines a unique RV. The inverse of this property is hasProbDist. This object property links one ordinary variable to the Skolem constant that represents that ordinary variable in quantified expressions. The property is inverse functional, since one Skolem constant can represent only the group of entities that can be substituted by that ordinary variable in the model. The inverse property is representsOVar. This object property links an individual of class Node to the MFrag(s) that have this node as a resident node. The inverse property is hasResidentNode This object property links one instance of class OVariable to type of the entity that can substitute it. Each argument of a RV has its expected type defined within the home MFrag of that RV. In PR-OWL, the type restrictions are defined directly through the OVariable using the isSubsBy property. One MFrag can have many OVariables (which can be themselves linked to many SimpleArgRelationships) but each OVariable has a unique type, which is explicitly defined by the type of the entity that can substibute that OVariable. This object property is the inverse of subsOVar. This is the inverse of hasType object property, and basically lists all the MEBN entities that have its respective type defined by that specific individual of either the MetaEntity class or the ObjectEntity class. This object property links a Skolem constant (i.e. an individual of class Skolem) to the ordinary variable it represents in a quantifier expression. The property is functional since each Skolem constant represents only one ordinary variable in the model. The inverse property is isRepBySkolem. This object property assigns MetaEntity individuals in order to define the type of the substituters for each MFrag ordinary variable. Its inverse property is the functional isSubsBy. This datatype property assigns the argument number of an argument relationship. As an example, if we have a random variable with 3 arguments, it will have three ArgRelatioship reified relations. The first argument of the RV will have the number 1 assigned to its respective hasArgNumber property, the second will have the number 2 assigned and the third will have the number 3 assigned. In short this property keeps track of the ordering between the arguments of an RV. The datatype itself is a nonNegativeInteger. We used this instead of a positiveInteger because we wanted zero as a possible value, since we assume that a RV with no arguments means a global RV. This datatype property conveys the declarative probability distributions. Each probability distribution can be expressed in different formats and each format is defined by the datatype property isRepresentedAs. Possible formats include Netica tables, Netica equations, Quiddity formulas, MEBN syntax, and others. However, the declaration itself is stored as a string so parsers are expected to understand how to deal with the specific text format of each declaration. This datatype property is used to store the actual probability of an individual ProbAssign. Currently, OWL has no support for user defined datatypes, so instead of using owl-p:prob datatype (which includes all decimals between 0 and 1 inclusive) we are using xsd:decimal for compatibility purposes. MEBN logic has the unique naming assumption, which is not assumed in OWL (even though tools such as Protege make that assumption for improved reasoning purposes). In order to make sure that a tool that does not assume unique identifies would not prevent MEBN reasoners to work, each MEBN entity has a unique identifier assigned by this datatype property. The UID itself is conveyed as a xsd:string, and the hasUID datatype property is declared as functional in order to enforce uniqueness. This property refers to an optional attribute of a node related with its respective graphical representation. It conveys the absolute vertical position of a node, measured in pixels, within a grid. MEBN includes the graphical representation in its formal definition, thus this property is applicable to all implementations of MEBN logic, including PR-OWL. This property was introduced in version 1.02 This datatype property indicates whether a probability distribution is the default probability distribution of a node or not. Default probability distributions for nodes are used when the context nodes of the MFrag containing those nodes are not met. This datatype property is used to define a given state of a random variable as exclusive within an MTheory. That is, among all instances of RV (say) "A", only one will have state "x" as true. Thus, if one copy of RV "A" is known to be in state "x", then all other instances of "A" withing that MTheory will be in states other than "x". If "A" is binary, knowing that one instance of "A" is True and that True in "A" is a Globally Exclusive state, then we know that all other instances of "A" are False. This datatype property defines how a given declarative probability distribution is expressed. Each probability distribution can be expressed in different formats, and each format is defined by this datatype property. Possible formats include Netica tables, Netica equations, Quiddity formulas, MEBN syntax, and others. However, the declaration itself is stored in the hasDeclaration datatype property as a string so parsers will have to know how to deal with the specific text format of each declaration. This MetaEntity should be applied to the truth-values T, F and ⊥ (absurd). !Boolean This MetaEntity should be assigned to the labels for the states of random variables whose domain is a list of categorical values !CategoryLabel This MetaEntity shold be assigned for the labels of all domain specific types and subtypes. !TypeLabel This state is used for the cases in which a truth-value cannot be applied to a random variable (i.e. meaningless, undefined, or contradictory hypotheses). ⊥ This state corresponds to the meaningfull hypotheses that have a false truth-value. F This state corresponds to the meaningfull hypotheses that have a false truth-value. T