A Dependency specifies a derived property - the outputDimension - as a function of other properties - the inputDimensions. An OperatorDependency is a Dependency specifying the derivation logic with an Operator (builtin, or conform to the Expression ontology). A Constraint is a Dependency specifying the feasibility of an instance with a boolean outputDimension. An Aggregation is a Dependency gathering the inputs from a set of associated instances: the Aggregation scope.
The Dependency ontology allows to specify derived properties and their derivations. ## Concept Dependency The following concepts are formalized: - **Dependency**: specifies a derived Dimension of an Observable - **InputsDependency**: specifies the derivation from a set of Dimensions - **Aggregation**: specifies the derivation from a scope of associated objects ```mermaid classDiagram direction TB namespace observable { class Observation:::obs class Dimension:::obs } Observation --> Dimension :observedDimensions class Dependency { operator: Operator } Dependency --|> Observation class InputsDependency class Aggregation { scope } Dependency <|-- Aggregation Dependency <|-- InputsDependency Dimension <-- InputsDependency : inputDimensions Dimension <-- Dependency : outputDimension Dimension <-- Aggregation : inputDimensionScope Dimension <-- Aggregation : inputDimensionThis classDef default fill:#f96,color:black classDef obs fill:#e9edc9,color:black ``` ## Concept Constraint The following concepts are formalized: - **Constraint**: a Dependency specifying the feasibility of the Observable - **ConstrainedObservable**: the class of Observables with Constraints - **Constrained**: the base class of ConstrainedObservable's ```mermaid classDiagram direction BT namespace UpperOntology { class Constraint class Dependency class Observable class ConstrainedObservable class Observation } Observable <-- Observation : observationObservable Dependency --|> Observation Constraint --|> Dependency ConstrainedObservable --|> Observable namespace DomainOntology{ class Constrained{ feasible: boolean } class aConstrained:::user class aConstraint:::user } aConstraint --> Constraint : type aConstrained --> ConstrainedObservable : type aConstrained --|> Constrained Constrained --> Constraint: violatingConstraint namespace DomainData{ class aConstrainedInstance:::user{ feasible: false } } aConstrainedInstance --> aConstrained : type classDef default fill:#f96,color:black classDef owl fill:#e9edc9,color:black classDef user fill:white,color:black ```
The Dependency Ontology
An ontology of dependencies, allowing specify to derived properties and their derivations
The Dependency ontology allows to specify derived properties and their derivations. A derived property is a property of an Observable that depends (is derived from) on other Dimensions of that Observable. The Dimensions the derived property depends on can be a given set of Dimensions, or a given Dimension on a set of associated instances (the scope of the aggregation). A particular case of Dependency is a Constraint, where the derived property is a boolean specifying the validity (or feasibility) of the Observable.
A Dependency specifying its inputs wiht a scope and a Dimension in that scope
The class of instances with constraints. The base class of ConstrainedObservable's
The class ConstrainedObservable is the subset of Observables with Constraints
A Constraint is an Dependency with observed dimensions as inputs and BooleanDimension as ouput
An Observation specifying a derived Dimension
A Dependency with a set of input Dimensions
A Dependency specifying the derivation logic with an Operator
Members of ConstrainedObservable are subClassOf Constrained
Observable with Constraints are members of ConsrainedObservable
The property specifying the scope of the aggregation
The aggregated Dimension (over the scope)
An extra Dimension on the Observable that will be considered in the aggregation
The Dimensions the derived Dimension depends on
The derived Dimension specified by the Dependency