pr-owl.owl
type: Ontology
comment: 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.
version info: 1.04

ArgRelationship
type: Class
comment: 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.
subclass of: Restriction
  on property: hasArgNumber
  cardinality: 1
subclass of: Thing
subclass of: Restriction
  on property: isArgumentOf
  all values from: Node
subclass of: Restriction
  on property: hasArgTerm
  all values from: Class
    union of: Entity
    union of: OVariable
    union of: Node
    union of: Exemplar

Entity
type: Class
comment: 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.
subclass of: Restriction
  on property: hasType
  some values from: MetaEntity
subclass of: Restriction
  on property: hasType
  all values from: MetaEntity
subclass of: Thing
subclass of: Restriction
  on property: hasUID
  cardinality: 1
subclass of: Restriction
  on property: hasType
  cardinality: 1
subclass of: Restriction
  on property: isPossibleValueOf
  all values from: Class
    union of: BuiltInRV
    union of: Node
subclass of: Restriction
  on property: isConditionantOf
  all values from: ProbAssign

OVariable
type: Class
comment: Ordinary variables are placeholders used in MFrags to refer to non-specific entities as arguments in a given MFrag's RVs.
equivalent class: Class
  intersection of: Restriction
    on property: isOVariableIn
    cardinality: 1
  intersection of: Restriction
    on property: isArgTermIn
    all values from: ArgRelationship
  intersection of: Restriction
    on property: isOVariableIn
    all values from: MFrag
  intersection of: Restriction
    on property: isSubsBy
    some values from: MetaEntity
  intersection of: Restriction
    on property: isArgTermIn
    some values from: ArgRelationship
  intersection of: Restriction
    on property: representsOVar
    all values from: Exemplar
  intersection of: Restriction
    on property: isOVariableIn
    some values from: MFrag
  intersection of: Restriction
    on property: isSubsBy
    cardinality: 1
  intersection of: Restriction
    on property: isSubsBy
    all values from: MetaEntity

Node
type: Class
comment: 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).
subclass of: Restriction
  on property: isInnerTermOf
  all values from: Node
subclass of: Restriction
  on property: hasPossibleValues
  all values from: Entity
subclass of: Restriction
  on property: hasArgument
  all values from: ArgRelationship
subclass of: Restriction
  on property: hasPossibleValues
  some values from: Entity
subclass of: Thing
subclass of: Restriction
  on property: isNodeFrom
  some values from: MFrag
subclass of: Restriction
  on property: hasInnerTerm
  all values from: Node
subclass of: Restriction
  on property: isNodeFrom
  all values from: MFrag

Exemplar
type: Class
comment: 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.
subclass of: Restriction
  on property: isArgTermIn
  all values from: ArgRelationship
subclass of: Restriction
  on property: isExemplarIn
  some values from: MFrag
subclass of: Restriction
  on property: representsOVar
  all values from: OVariable
subclass of: Thing
subclass of: Restriction
  on property: isArgTermIn
  some values from: ArgRelationship
subclass of: Restriction
  on property: isExemplarIn
  all values from: MFrag
subclass of: Restriction
  on property: representsOVar
  some values from: OVariable

BooleanRVStates
type: Class
comment: The BooleanRVStates class is formed by the Boolean truth-value states and are applied to Boolean random variables.
subclass of: Entity
subclass of: Restriction
  on property: hasType
  has value: Boolean
disjoint with: CategoricalRVStates
disjoint with: MetaEntity
disjoint with: ObjectEntity

BuiltInRV
type: Class
comment: 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.
subclass of: Restriction
  on property: hasInputInstance
  all values from: Input
subclass of: Restriction
  on property: hasPossibleValues
  some values from: BooleanRVStates
subclass of: Thing
subclass of: Restriction
  on property: hasPossibleValues
  all values from: BooleanRVStates
disjoint with: Domain Res
disjoint with: Finding res

CategoricalRVStates
type: Class
comment: 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.
subclass of: Entity
subclass of: Restriction
  on property: hasType
  has value: CategoryLabel
disjoint with: ObjectEntity
disjoint with: BooleanRVStates
disjoint with: MetaEntity

CondRelationship
type: Class
comment: 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).
subclass of: Restriction
  on property: hasParentName
  all values from: Node
subclass of: Thing
subclass of: Restriction
  on property: hasParentState
  some values from: Entity
subclass of: Restriction
  on property: hasParentName
  cardinality: 1
subclass of: Restriction
  on property: hasParentName
  some values from: Node
subclass of: Restriction
  on property: hasParentState
  cardinality: 1
subclass of: Restriction
  on property: isConditionantOf
  some values from: ProbAssign
subclass of: Restriction
  on property: hasParentState
  all values from: Entity

Context
type: Class
comment: 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.
subclass of: Restriction
  on property: hasPossibleValues
  all values from: Entity
subclass of: Restriction
  on property: isContextInstanceOf
  cardinality: 1
subclass of: Restriction
  on property: hasPossibleValues
  some values from: Entity
subclass of: Restriction
  on property: hasInnerTerm
  all values from: Context
subclass of: Node
subclass of: Restriction
  on property: isContextNodeIn
  all values from: Domain MFrag
disjoint with: Resident
disjoint with: Input

DeclarativeDist
type: Class
comment: 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).
equivalent class: Class
  intersection of: Restriction
    on property: isProbDistOf
    cardinality: 1
  intersection of: Restriction
    on property: isRepresentedAs
    min cardinality: 1
  intersection of: ProbDist
  intersection of: Restriction
    on property: isProbDistOf
    some values from: Resident
  intersection of: Restriction
    on property: isProbDistOf
    all values from: Resident
  intersection of: Restriction
    on property: hasDeclaration
    min cardinality: 1
disjoint with: PR-OWLTable

ProbDist
type: Class
comment: 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).
subclass of: Thing
subclass of: Restriction
  on property: isProbDistOf
  some values from: Resident
subclass of: Restriction
  on property: isProbDistOf
  all values from: Resident

Domain MFrag
type: Class
comment: 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.
subclass of: Restriction
  on property: hasContextNode
  all values from: Context
subclass of: MFrag
disjoint with: Finding MFrag

MFrag
type: Class
comment: 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).
subclass of: Restriction
  on property: hasInputNode
  all values from: Input
subclass of: Restriction
  on property: hasResidentNode
  some values from: Resident
subclass of: Restriction
  on property: isMFragOf
  all values from: MTheory
subclass of: Restriction
  on property: hasResidentNode
  min cardinality: 1
subclass of: Restriction
  on property: hasNode
  some values from: Node
subclass of: Thing
subclass of: Restriction
  on property: hasOVariable
  all values from: OVariable
subclass of: Restriction
  on property: hasNode
  all values from: Node
subclass of: Restriction
  on property: hasExemplar
  all values from: Exemplar
subclass of: Restriction
  on property: hasResidentNode
  all values from: Resident

Domain Res
type: Class
comment: This is the subclass of class Resident (node) that includes all domain-specific resident nodes. It is disjoint with classes Finding_res and BuiltInRV.
subclass of: Class
  union of: Domain Res
  union of: Restriction
    on property: hasParent
    all values from: Generative input
subclass of: Restriction
  on property: isResidentNodeIn
  some values from: Domain MFrag
subclass of: Restriction
  on property: isParentOf
  all values from: Domain Res
subclass of: Restriction
  on property: isResidentNodeIn
  all values from: Domain MFrag
subclass of: Resident
disjoint with: Finding res
disjoint with: BuiltInRV

Resident
type: Class
comment: Resident nodes are the random variables that have their respective probability distribution defined in the MFrag.
subclass of: Restriction
  on property: hasArgument
  all values from: SimpleArgRelationship
subclass of: Restriction
  on property: hasProbDist
  some values from: ProbDist
subclass of: Restriction
  on property: hasPossibleValues
  all values from: Entity
subclass of: Restriction
  on property: hasPossibleValues
  some values from: Entity
subclass of: Restriction
  on property: hasProbDist
  all values from: ProbDist
subclass of: Node
subclass of: Restriction
  on property: isResidentNodeIn
  all values from: MFrag
subclass of: Restriction
  on property: hasInnerTerm
  all values from: Resident
subclass of: Restriction
  on property: isArgTermIn
  all values from: ArgRelationship
subclass of: Restriction
  on property: isParentOf
  all values from: Resident
subclass of: Restriction
  on property: isResidentNodeIn
  min cardinality: 1
subclass of: Restriction
  on property: hasParent
  all values from: Class
    union of: Input
    union of: Resident
subclass of: Restriction
  on property: isResidentNodeIn
  some values from: MFrag
disjoint with: Context
disjoint with: Input

Finding MFrag
type: Class
comment: 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.
subclass of: Restriction
  on property: hasInputNode
  some values from: Finding input
subclass of: Restriction
  on property: hasInputNode
  cardinality: 1
subclass of: Restriction
  on property: hasInputNode
  all values from: Finding input
subclass of: MFrag
subclass of: Restriction
  on property: hasResidentNode
  some values from: Finding res
subclass of: Restriction
  on property: hasResidentNode
  all values from: Finding res
subclass of: Restriction
  on property: hasResidentNode
  cardinality: 1
disjoint with: Domain MFrag

Finding input
type: Class
subclass of: Input
subclass of: Restriction
  on property: isInputNodeIn
  some values from: Finding MFrag
subclass of: Restriction
  on property: isParentOf
  some values from: Finding res
subclass of: Restriction
  on property: isInputInstanceOf
  some values from: Finding res
subclass of: Restriction
  on property: isInputNodeIn
  all values from: Finding MFrag
subclass of: Restriction
  on property: isParentOf
  all values from: Finding res
subclass of: Restriction
  on property: isParentOf
  cardinality: 1
subclass of: Restriction
  on property: isInputInstanceOf
  cardinality: 1
subclass of: Restriction
  on property: isInputInstanceOf
  all values from: Finding res
disjoint with: Generative input

Input
type: Class
comment: 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.
subclass of: Restriction
  on property: isParentOf
  some values from: Resident
subclass of: Restriction
  on property: hasArgument
  all values from: SimpleArgRelationship
subclass of: Restriction
  on property: isParentOf
  all values from: Resident
subclass of: Restriction
  on property: isParentOf
  min cardinality: 1
subclass of: Restriction
  on property: isInputInstanceOf
  some values from: Class
    union of: BuiltInRV
    union of: Resident
subclass of: Restriction
  on property: hasInnerTerm
  all values from: Input
subclass of: Restriction
  on property: isInputNodeIn
  all values from: MFrag
subclass of: Restriction
  on property: isInputInstanceOf
  cardinality: 1
subclass of: Node
subclass of: Restriction
  on property: isInputNodeIn
  some values from: MFrag
subclass of: Restriction
  on property: isInputInstanceOf
  all values from: Class
    union of: BuiltInRV
    union of: Resident
disjoint with: Resident
disjoint with: Context

Finding res
type: Class
comment: 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.
subclass of: Restriction
  on property: isParentOf
  cardinality: 0
subclass of: Restriction
  on property: hasParent
  cardinality: 1
subclass of: Restriction
  on property: hasParent
  all values from: Finding input
subclass of: Restriction
  on property: hasPossibleValues
  all values from: Class
    one of: true
    one of: absurd
subclass of: Restriction
  on property: isResidentNodeIn
  all values from: Finding MFrag
subclass of: Restriction
  on property: hasPossibleValues
  some values from: Class
    one of: true
    one of: absurd
subclass of: Resident
subclass of: Restriction
  on property: hasParent
  some values from: Finding input
subclass of: Restriction
  on property: isResidentNodeIn
  some values from: Finding MFrag
disjoint with: Domain Res
disjoint with: BuiltInRV

true
type: Thing
comment: This state corresponds to the meaningfull hypotheses that have a false truth-value.
type: BooleanRVStates
is possible value of: equalto
is possible value of: not
is possible value of: and
is possible value of: exists
is possible value of: or
is possible value of: implies
is possible value of: forall
is possible value of: iff
has type: Boolean
has UID: T

absurd
type: Thing
comment: 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).
type: BooleanRVStates
is possible value of: equalto
is possible value of: not
is possible value of: and
is possible value of: exists
is possible value of: or
is possible value of: implies
is possible value of: forall
is possible value of: iff
has type: Boolean
has UID: ⊥

MTheory
type: Class
comment: 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.
subclass of: Restriction
  on property: hasMFrag
  some values from: MFrag
subclass of: Thing
subclass of: Restriction
  on property: hasMFrag
  all values from: MFrag

MetaEntity
type: Class
comment: The MetaEntity class includes all the entities that convey specific definitions about entities (e.g. typelabels that name the possible types of entities).
subclass of: Entity
equivalent class: Class
  intersection of: Restriction
    on property: isTypeOf
    some values from: Entity
  intersection of: Restriction
    on property: isTypeOf
    all values from: Entity
disjoint with: ObjectEntity
disjoint with: BooleanRVStates
disjoint with: CategoricalRVStates

ObjectEntity
type: Class
comment: 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.
subclass of: Entity
subclass of: Restriction
  on property: subsOVar
  all values from: OVariable
disjoint with: MetaEntity
disjoint with: CategoricalRVStates
disjoint with: BooleanRVStates

PR-OWLTable
type: Class
comment: 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.
subclass of: Restriction
  on property: isProbDistOf
  cardinality: 1
subclass of: ProbDist
subclass of: Restriction
  on property: hasProbAssign
  all values from: ProbAssign
subclass of: Restriction
  on property: isProbDistOf
  some values from: Resident
subclass of: Restriction
  on property: isProbDistOf
  all values from: Resident
subclass of: Restriction
  on property: hasProbAssign
  some values from: ProbAssign
disjoint with: DeclarativeDist

ProbAssign
type: Class
comment: 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.
subclass of: Restriction
  on property: hasConditionant
  some values from: CondRelationship
subclass of: Restriction
  on property: hasConditionant
  all values from: CondRelationship
subclass of: Thing
subclass of: Restriction
  on property: hasStateName
  cardinality: 1
subclass of: Restriction
  on property: hasStateProb
  cardinality: 1
subclass of: Restriction
  on property: hasStateName
  some values from: Entity
subclass of: Restriction
  on property: hasStateName
  all values from: Entity

SimpleArgRelationship
type: Class
comment: 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.
equivalent class: Class
  intersection of: Restriction
    on property: isArgumentOf
    max cardinality: 1
  intersection of: Restriction
    on property: hasArgTerm
    some values from: OVariable
  intersection of: Restriction
    on property: isArgumentOf
    all values from: Node
  intersection of: Restriction
    on property: hasArgTerm
    all values from: OVariable
  intersection of: ArgRelationship

hasArgTerm
type: ObjectProperty
comment: 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.
type: FunctionalProperty
inverse of: isArgTermIn
domain: ArgRelationship
range: Class
  union of: Entity
  union of: OVariable
  union of: Exemplar
  union of: Resident

isArgTermIn
type: ObjectProperty
comment: 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.
type: InverseFunctionalProperty
inverse of: hasArgTerm
domain: Class
  union of: Entity
  union of: OVariable
  union of: Exemplar
  union of: Resident
range: ArgRelationship

hasArgument
type: ObjectProperty
comment: 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
type: InverseFunctionalProperty
inverse of: isArgumentOf
domain: Node
range: ArgRelationship

isArgumentOf
type: ObjectProperty
comment: 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.
type: FunctionalProperty
inverse of: hasArgument
domain: ArgRelationship
range: Node

hasConditionant
type: ObjectProperty
comment: 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
inverse of: isConditionantOf
domain: ProbAssign
range: CondRelationship

isConditionantOf
type: ObjectProperty
comment: 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.
inverse of: hasConditionant
domain: CondRelationship
range: ProbAssign

hasContextInstance
type: ObjectProperty
comment: 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.
type: InverseFunctionalProperty
inverse of: isContextInstanceOf
domain: Class
  union of: Domain Res
  union of: BuiltInRV
range: Context

isContextInstanceOf
type: ObjectProperty
comment: 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
type: FunctionalProperty
inverse of: hasContextInstance
domain: Context
range: Class
  union of: Domain Res
  union of: BuiltInRV

hasContextNode
type: ObjectProperty
comment: This object property links an MFrag to the context nodes being applied to it. The inverse property is isContextIn
inverse of: isContextNodeIn
domain: Domain MFrag
range: Context
sub property of: hasNode

isContextNodeIn
type: ObjectProperty
comment: This object property links one context node to the respective MFrag in which that context node applies. The inverse property is hasContext.
inverse of: hasContextNode
domain: Context
range: Domain MFrag
sub property of: isNodeFrom

hasExemplar
type: ObjectProperty
comment: 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.
inverse of: isExemplarIn
domain: MFrag
range: Exemplar

isExemplarIn
type: ObjectProperty
comment: 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.
inverse of: hasExemplar
domain: Exemplar
range: MFrag

hasInnerTerm
type: ObjectProperty
comment: 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.
inverse of: isInnerTermOf
domain: Node
range: Node

isInnerTermOf
type: ObjectProperty
comment: This object property is used to model expressions. The inverse property is hasInnerTerm
inverse of: hasInnerTerm
domain: Node
range: Node

hasInputInstance
type: ObjectProperty
comment: 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.
type: InverseFunctionalProperty
inverse of: isInputInstanceOf
domain: Class
  union of: BuiltInRV
  union of: Resident
range: Input

isInputInstanceOf
type: ObjectProperty
comment: 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.
type: FunctionalProperty
inverse of: hasInputInstance
domain: Input
range: Class
  union of: BuiltInRV
  union of: Resident

hasInputNode
type: ObjectProperty
comment: This object property links each MFrag with its respective input nodes. The inverse property is isInputNodeIn
inverse of: isInputNodeIn
domain: MFrag
range: Input
sub property of: hasNode

isInputNodeIn
type: ObjectProperty
comment: This object property links a node to the MFrags that have it as an input. The inverse property is hasInputNode.
inverse of: hasInputNode
domain: Input
range: MFrag
sub property of: isNodeFrom

hasMFrag
type: ObjectProperty
comment: 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
inverse of: isMFragOf
domain: MTheory
range: MFrag

isMFragOf
type: ObjectProperty
comment: 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.
inverse of: hasMFrag
domain: MFrag
range: MTheory

hasNode
type: ObjectProperty
comment: This object property links one MFrag with its nodes. The inverse property is isNodeFrom
inverse of: isNodeFrom
domain: MFrag
range: Node

isNodeFrom
type: ObjectProperty
comment: This general object property links one node to the MFrag it belongs to. The inverse property is hasNode
inverse of: hasNode
domain: Node
range: MFrag

hasOVariable
type: ObjectProperty
comment: 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.
type: InverseFunctionalProperty
inverse of: isOVariableIn
domain: MFrag
range: OVariable

isOVariableIn
type: ObjectProperty
comment: 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.
type: FunctionalProperty
inverse of: hasOVariable
domain: OVariable
range: MFrag

hasParent
type: ObjectProperty
comment: 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.
inverse of: isParentOf
domain: Resident
range: Class
  union of: Input
  union of: Resident

isParentOf
type: ObjectProperty
comment: 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.
inverse of: hasParent
domain: Class
  union of: Input
  union of: Resident
range: Resident

hasParentName
type: ObjectProperty
comment: 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.
type: FunctionalProperty
domain: CondRelationship
range: Node

hasParentState
type: ObjectProperty
comment: 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.
type: FunctionalProperty
domain: CondRelationship
range: Entity

hasPossibleValues
type: ObjectProperty
comment: 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
inverse of: isPossibleValueOf
domain: Class
  union of: BuiltInRV
  union of: Node
range: Entity

isPossibleValueOf
type: ObjectProperty
comment: 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.
inverse of: hasPossibleValues
domain: Entity
range: Class
  union of: BuiltInRV
  union of: Node

hasProbAssign
type: ObjectProperty
comment: 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.
type: InverseFunctionalProperty
inverse of: isProbAssignIn
domain: PR-OWLTable
range: ProbAssign

isProbAssignIn
type: ObjectProperty
comment: This is the inverse of the hasProbAssign object property and links one individual probability assignment to its respective probability distribution table.
type: FunctionalProperty
inverse of: hasProbAssign
domain: ProbAssign
range: PR-OWLTable

hasProbDist
type: ObjectProperty
comment: 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.
inverse of: isProbDistOf
domain: Resident
range: ProbDist

isProbDistOf
type: ObjectProperty
comment: 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.
inverse of: hasProbDist
domain: ProbDist
range: Resident

hasResidentNode
type: ObjectProperty
comment: This object property links an MFrag with its respective resident node(s). The inverse property is isResidentNodeIn
inverse of: isResidentNodeIn
domain: MFrag
range: Resident
sub property of: hasNode

isResidentNodeIn
type: ObjectProperty
comment: 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
inverse of: hasResidentNode
domain: Resident
range: MFrag
sub property of: isNodeFrom

hasStateName
type: ObjectProperty
comment: 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.
type: FunctionalProperty
domain: ProbAssign
range: Entity

hasType
type: ObjectProperty
comment: 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.
type: FunctionalProperty
inverse of: isTypeOf
domain: Entity
range: MetaEntity

isTypeOf
type: ObjectProperty
comment: 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.
type: InverseFunctionalProperty
inverse of: hasType
domain: MetaEntity
range: Entity

isRepBySkolem
type: ObjectProperty
comment: 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.
type: InverseFunctionalProperty
inverse of: representsOVar
domain: OVariable
range: Exemplar

representsOVar
type: ObjectProperty
comment: 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.
type: FunctionalProperty
inverse of: isRepBySkolem
domain: Exemplar
range: OVariable

isSubsBy
type: ObjectProperty
comment: 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.
type: FunctionalProperty
inverse of: subsOVar
domain: OVariable
range: MetaEntity

subsOVar
type: ObjectProperty
comment: 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.
type: InverseFunctionalProperty
inverse of: isSubsBy
domain: MetaEntity
range: OVariable

hasArgNumber
type: DatatypeProperty
comment: 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.
type: FunctionalProperty
domain: ArgRelationship
range: nonNegativeInteger

hasDeclaration
type: DatatypeProperty
comment: 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.
type: FunctionalProperty
domain: DeclarativeDist
range: string

hasStateProb
type: DatatypeProperty
comment: 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.
type: FunctionalProperty
domain: ProbAssign
range: decimal

hasUID
type: DatatypeProperty
comment: 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.
type: FunctionalProperty
domain: Entity
range: string

hasVerticalPosition
type: DatatypeProperty
comment: 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.
version info: This property was introduced in version 1.02
type: FunctionalProperty
domain: Node
range: decimal

isDefault
type: DatatypeProperty
comment: 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.
type: FunctionalProperty
domain: ProbDist
range: boolean

isGloballyExclusive
type: DatatypeProperty
comment: 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.
type: FunctionalProperty
domain: Class
  union of: CategoricalRVStates
  union of: BooleanRVStates
range: boolean

isRepresentedAs
type: DatatypeProperty
comment: 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.
type: FunctionalProperty
domain: DeclarativeDist
type: Thing

Boolean
type: MetaEntity
comment: This MetaEntity should be applied to the truth-values T, F and ⊥ (absurd).
is type of: true
is type of: absurd
is type of: false
has type: TypeLabel
has UID: !Boolean

CategoryLabel
type: MetaEntity
comment: This MetaEntity should be assigned to the labels for the states of random variables whose domain is a list of categorical values
has type: TypeLabel
has UID: !CategoryLabel

TypeLabel
type: MetaEntity
comment: This MetaEntity shold be assigned for the labels of all domain specific types and subtypes.
is type of: CategoryLabel
is type of: Boolean
has UID: !TypeLabel

false
type: BooleanRVStates
comment: This state corresponds to the meaningfull hypotheses that have a false truth-value.
is possible value of: not
is possible value of: equalto
is possible value of: and
is possible value of: exists
is possible value of: or
is possible value of: implies
is possible value of: forall
is possible value of: iff
has type: Boolean
has UID: F