Industrial Ontology Foundry (IOF) Maintenance Reference Ontology
type: Ontology
label: Maintenance Ontology
abstract: The purpose of this IOF Maintenance Reference ontology is to support semantic interoperatibility through the use modular ontologies in the maintenance domain. This Ontology contains terms and concepts identified as common in a number of application ontologies for maintenance management, maintenance procedures, asset failure and failure modes and effects analysis. The ontology is aligned with the IOF Core Ontology which is aligned with Basic Formal Ontology and importas terms for other domain independent ontologies.
contributor: Caitlin Woods, University of Western Australia
contributor: Markus Stumptner, University of South Australia
contributor: Matt Selway, University of South Australia
contributor: Melinda Hodkiewicz, University of Western Australia
creator: IOF Maintenance Working Group
license: http://opensource.org/licenses/MIT
publisher: Industrial Ontology Foundry
references: terms
references: core#
imports: Core
version IRI: Maintenance
copyright: Copyright (c) 2022, 2023, 2024, 2025 Open Applications Group
maturity: Released

degraded state
type: Class
subclass of: maintenance state
example: having a small crack, having a partial blockage, having an oscillating reading
first order logic axiom: DegradedState(x) → MaintenanceState(x)
is primitive: true
natural language definition: state of reduced ability to perform as required but with acceptable reduced performance
primitive rationale: we do not have the terms to deal with the concepts in the 2nd half of the NL definition about 'grade of realization'
semi formal natural language axiom: if x is a 'degraded state' then x is a 'maintenance state'

disposition to exhibit undesirable behavior
type: Class
subclass of: undesireable disposition
subclass of: Restriction
  on property: BFO_0000054
  all values from: Class
    complement of: failure process
example: overspeed, excessive noise
first order logic axiom: LA1: DispositionToUndesirableBehavior(x) → UndesirableDisposition(x)
first order logic axiom: LA2: ∀p(DispositionToExibitUndesirableBehavior(d) ∧ Process(p) ∧ realizes(p, d) → ¬ FailureProcess(p))
is primitive: true
natural language definition: disposition of an item that would not be expected under normal operating conditions
primitive rationale: the item may or may not exhibit this behavior hence this is difficult to define clearly
semi formal natural language axiom: LA1: if x is a 'disposition to undesirable behavior' then x is a 'undesirable disposition'
semi formal natural language axiom: LA2: if x is a 'disposition to undesirable behavior' and x 'realizes' some 'process' p then p is not a 'failure process'

disposition to fail
type: Class
subclass of: undesireable disposition
subclass of: Restriction
  on property: BFO_0000054
  some values from: failure process
example: disposition to explode, disposition to fracture, disposition to sieze
first order logic axiom: DispositionToFail(x) → UndesireableDisposition(x) ∧ ∃y(FailureProcess(y) ∧ hasRealization(x,y))
is primitive: true
natural language definition: disposition of an item to undergo a failure process
primitive rationale: As a disposition will come into its existance prior to its realization in a failure process necessary and sufficient conditions can not be created at this point due to a lack of patterns to express process types regardless of the time of their existence
semi formal natural language axiom: if x is a 'disposition to fail' then x is a 'undesireable disposition' that 'has realization' some 'failure process'

failed state
type: Class
subclass of: maintenance state
subclass of: Restriction
  on property: BFO_0000062
  some values from: Class
    union of: degraded state
    union of: operating state
subclass of: Restriction
  on property: BFO_0000167
  some values from: MaintainableMaterialItem
subclass of: Restriction
  on property:
    inverse of: initiates
  some values from: failure event
disjoint with: operating state
example: is broken in two, is burst, is failing to turn on
first order logic definition: FailedState(o1) ↔ MaintenanceState(o1) ∧ ∃i(MaintainableMaterialItem(i) ∧ hasParticipantAtAllTimes(o1, i) ∧ ∃e(FailureEvent(e) ∧ initiates(e, o1)) ∧ ∃o2((DegradedState(o2) ∨ OperatingState(o2) ∧ hasParticipantAtAllTimes(o2,i)) ∧ precedes(o2, o1)) ∧ ¬∃o3((DegradedState(o3) ∨ OperatingState(o3)) ∧ hasParticipantAtAllTimes(o3,i) ∧ precedes(o2, o3) ∧ precedes(o3, o1)))
is primitive: false
natural language definition: state of an item being unable to perform a required function due to a failure event
semi formal natural language definition: "failed state': every instance of 'failed state' is defined as exactly an instance of 'maintenance state' o1 that 'has participant at all times' some 'maintainable material item' i and that is 'initiated by' some 'failure event' and is 'preceded by' some ('degraded state' or 'operating state') o2 that 'has participant at all times' i and there is no ('degraded state' or 'operating state' ) o3 such that o3 'has participant at all times' i and o2 'precedes' o3 and o3 'precedes' o1"

failure effect
type: Class
subclass of: BFO_0000015
subclass of: Restriction
  on property: BFO_0000062
  some values from: Class
    union of: failure event
    union of: failure process
example: leaking pipe, erratic operation, equipment does not run
first order logic axiom: FailureEffect(x) → Process(x) ∧ ∃f((FailureEvent(f) ∨ FailureProcess(f)) ∧ precededBy(x, f))
is primitive: true
natural language definition: process that is the consequence of failure, within or beyond the boundary of the failed item
primitive rationale: it is not possible to determine that a process is a failure effect from the ontology alone and requires external analysis to identify such an occurrence.
semi formal natural language axiom: if x is a 'failure effect' then x is a 'process' that is 'preceded by' some 'failure event' or 'failure process'
usage note: Failure effect does not make any commitments to what types of BFO:process can or cannot be considered effects of (functional) failure. Therefore, failure effect can classify any BFO:process (part or whole), indicating that the process is considered the result of a failure for the purposes of maintenance.

failure event
type: Class
subclass of: Event
subclass of: Restriction
  on property: initiates
  some values from: failed state
see also: ISO81346 for examples of functions
example: explosion, seizure, loss of power, loss of control
explanatory note: the event can be the loss of the primary function or a combination of functions
first order logic definition: FailureEvent(e) ↔ Event(e) ∧ ∃o(FailedState(o) ∧ initiates(e, o)) ∧ ∃i,f,p1(MaintainableMaterialItem(i) ∧ hasParticipantAtAllTimes(e, i) ∧ PrimaryFunction(f) ∧ hasFunction(i, f) ∧ FunctioningProcess(p1) ∧ realizes(p1, f) ∧ precedes(p1, e) ∧ ¬∃p2(FunctioningProcess(p2) ∧ realizes(p2,f) ∧ precedes(p1, p2) ∧ precedes(p2, e)))
is primitive: false
natural language definition: event that causes an item to lose its ability to perform a required function
semi formal natural language definition: every instance of 'failure event' is defined as exactly an instance of 'event' e that 'initiates' some 'failed state' and that 'has participant at all times' some 'maintainable material item' that 'has function' some 'primary function ' f that 'has realization' some 'functioning process' p1 that 'precedes' e and there is no 'functioning process' p2 such that p2 'realizes' f and p1 'precedes' p2 and p2 'precedes' e
synonym: failure

failure mode code
type: Class
subclass of: InformationContentEntity
subclass of: Restriction
  on property: describes
  some values from: undesireable disposition
see also: ISO14224 for example list of failure modes
example: "high output", "leaking", "vibrating"
adapted from: The natural language definition is adapted from EN:13306
first order logic axiom: FailureModeCode(x) → InformationContentEntity(x) ∧ ∃y(UndesirableDisposition(y) ∧ describes(x,y))
is primitive: true
natural language definition: information content entity that describes an undesireable disposition
primitive rationale: at this stage we do not have sufficient constructs to create necessary and sufficent conditions for this class.
semi formal natural language axiom: if x is a 'failure mode code' then x is an 'information content entity' and there is some 'undesirable disposition' that 'is described by' x

failure process
type: Class
subclass of: BFO_0000015
equivalent class: Class
  intersection of: BFO_0000015
  intersection of: Restriction
    on property: BFO_0000055
    some values from: disposition to fail
example: short circuiting process, deformation process, corrosion process
first order logic definition: FailureProcess(x) ↔ Process(x) ∧ ∃y(DispositionToFail(y) ∧ realizes(x,y))
is primitive: false
natural language definition: process that changes some quality of an item causing the item to become degraded or failed
semi formal natural language definition: every instance of 'failure process' is defined as exactly an instance of 'process' that 'realizes' some 'disposition to fail'
synonym: functional failure

functioning process
type: Class
subclass of: BFO_0000015
see also: ISO81346 for examples of functioning processes associated with functions
equivalent class: Class
  intersection of: BFO_0000015
  intersection of: Restriction
    on property: BFO_0000055
    some values from: BFO_0000034
example: sensing process, controlling process, transforming process
adapted from: The natural language definition is adapted from EN:13306
first order logic definition: FunctioningProcess(x) ↔ Process(x) ∧ ∃y(Function(y) ∧ realizes(x,y))
is primitive: false
natural language definition: process in which an item performs its function
semi formal natural language definition: every instance of 'functioning process' is defined as exactly an instance of 'process' that 'realizes' some 'function'

maintenance activity
type: Class
subclass of: maintenance process
example: replace activity, repair activity, inspect activity
first order logic axiom: Maintenance Activity(x) → MaintenanceProcess(x)
is primitive: true
natural language definition: maintenance process that is a single task to retain or restore the function of a maintainable material item
primitive rationale: at this stage we do not have sufficient constructs to create necessary and sufficent conditions for this class.
semi formal natural language axiom: if x is a 'maintenance activity' then x is a 'maintenance process'

maintenance process
type: Class
subclass of: PlannedProcess
subclass of: Restriction
  on property: BFO_0000167
  some values from: MaintainableMaterialItem
subclass of: Restriction
  on property: hasInput
  some values from: MaintainableMaterialItem
subclass of: Restriction
  on property: prescribedBy
  some values from: maintenance strategy
example: process of replacing a pump, process of calibrating a sensor
first order logic axiom: LA1: PlannedProcess(p) ∧ (∃x(MaintenanceStrategy(x) ∧ prescribes(x, p)) → MaintenanceProcess(p)
first order logic axiom: LA2: MaintenanceProcess(p) → ∃x(MaintenanceStrategy(x) ∧ prescribes(x, p))
first order logic axiom: LA3: MaintenanceProcess(p) → ∃x(MaintainableMaterialItem(x) ∧ hasParticipantAtAllTimes(p, x) ∧ hasInput(p, x))
is primitive: true
natural language definition: process to do with retaining or restoring the function of a maintainable material item under a maintenance strategy
primitive rationale: Additional analysis to be performed, particularly w.r.t. the associated maintenance strategy.
semi formal natural language axiom: LA1: if p is 'planned process' that is prescribed by some 'maintenance strategy' then x is a 'maintenance process'
semi formal natural language axiom: LA2: if p is 'maintenance process' then there is some 'maintenance strategy' that 'prescribes' p
semi formal natural language axiom: LA3: if p is 'maintenance process' then there is some 'maintainable material item' x such that p 'has input' x and p 'has participant at all times' x

maintenance state
type: Class
subclass of: MaterialState
equivalent class: Class
  union of: degraded state
  union of: failed state
  union of: operating state
example: is broken in two, is running at desired speed
first order logic definition: MaintenanceState(x) ↔ Operating State(x) ∨ DegradedState(x) ∨ FailedState(x)
is primitive: false
natural language definition: stasis that holds during a temporal interval when the realizable functions and capabilities of the participating item, or the grade of realization of those functions and capabilities, remain unchanged
semi formal natural language definition: every instance of 'maintenance state' is defined as exactly an instance of 'operating state' or exactly an instance of 'degraded state' or exactly an instance of 'failed state'.

maintenance strategy
type: Class
subclass of: PlanSpecification
example: specification of a corrective strategy for maintaining a pump (or pumps) of a plant
first order logic axiom: PlanSpecification(x) ∧ (∃p(MaintenanceProcess(p) ∧ prescribes(x, p)) → MaintenanceStrategy(x)
is primitive: true
natural language definition: maintenance (method/ approach/ actions) to enable (the/an) asset to achieve (management's/ desired) objectives
primitive rationale: Additional analysis to be performed on this concept. Involves agents, organisations, and business objectives.
semi formal natural language axiom: if x is a 'plan specification' that 'prescribes' some 'maintenance process' then x is a 'maintenance strategy'

maintenance work order record
type: Class
subclass of: InformationContentEntity
equivalent class: Class
  intersection of: InformationContentEntity
  intersection of: Restriction
    on property: describes
    some values from: maintenance process
  intersection of: Restriction
    on property: isInputOf
    some values from: maintenance process
example: a record in a (computerised) maintenance management system that contains fields for due and actual date of the maintenance, a description of the maintenance task, actual and budget costs and other fields
acronym: MWO
explanatory note: the record has a number of commonly used fields including dates, task description, task codes, costs
explanatory note: this definition remains provisional because it assumes that a work order must involve a 'maintenance process'. In the current definition, a work order cannot be made up of purely 'supporting maintenance activity' tasks.
first order logic definition: MaintenanceWorkOrderRecord(x) ↔ InformationContentEntity(x) ∧ ∃y(MaintenanceProcess(y) ∧ describes(x, y) ∧ isInputOf(x, y))
is primitive: false
natural language definition: information content entity that describes a maintenance process
semi formal natural language definition: every instance of 'maintenance work order' is defined as exactly an instance of 'information content entity' that 'describes' some 'maintenance process' p and that 'is input of' p
synonym: maintenance work order

operating state
type: Class
subclass of: maintenance state
example: running at desired speed, producing required power, pumping desired volume
explanatory note: In defining the state of an item as being able to perform a required function, we are assuming that the external resources, if required, are provided
explanatory note: Note that in an operating state the item may be functional (so in the operating state) and not currently operating (performing in the functioning process)
first order logic axiom: OperatingState(x) → MaintenanceState(x)
is primitive: true
natural language definition: state of an item being able to perform a required function
primitive rationale: generally speaking, the determination of maintenance state is determined from outside of the ontology, e.g., through analytics, other reasoning mechanims, or by reports from the device or control system, and so is not determinable from the ontology alone. The required constructs for creation of a formal definition are not available in this release.
semi formal natural language axiom: if x is a 'operating state' then x is a 'maintenance state'

qualification specification
type: Class
subclass of: RequirementSpecification
example: electrical trade qualification, welding qualification, registered engineer
first order logic axiom: QualificationSpecification(x) → RequirementSpecification(x)
is primitive: true
natural language definition: requirement specification that identifies the need for a person to have an assessed skill for a specific task
primitive rationale: detailed analysis of this concept is incomplete and, hence, the required constructs for creation of a formal definition are not available in this release.
semi formal natural language axiom: if x is a 'qualification specification' then x is a 'requirement specification'

qualified maintenance person
type: Class
subclass of: Person
see also: qualification specification
equivalent class: Class
  intersection of: Person
  intersection of: Restriction
    on property: BFO_0000056
    some values from: maintenance activity
  intersection of: Restriction
    on property: satisfiesRequirement
    some values from: Class
      intersection of: qualification specification
      intersection of: Restriction
        on property: prescribes
        some values from: maintenance activity
example: electrician, fitter, mechanic
explanatory note: Qualified person on its own is not particularly useful unless reasoning is constrained to only the individuals of interest at some time. Specific subtypes of qualified person are necessary to determine if specific qualification types are satisfied. Still, care must be taken when reasoning over temporal information as, if the critieria are met at some time, the classification will hold.
first order logic definition: QualifiedMaintenancePerson(x) ↔ Person(x) ∧ ∃y(MaintenanceActivity(y) ∧ partcipatesInAtSomeTime(x,y) ∧ ∃z(QualificationSpecification(z) ∧ prescribedBy(y, z) ∧ satisfiesRequirement(x,z)))
is primitive: false
natural language definition: person who is qualified to perform a specified specified maintenance activity
semi formal natural language definition: every instance of ‘qualified maintenance person’ is defined as exactly an instance of 'person' that 'participates in at some time' some 'maintenance activity' p and that 'satifies' some 'qualification specification' that 'prescribes' p

required function
type: Class
subclass of: BFO_0000034
subclass of: Class
  intersection of: Restriction
    on property: BFO_0000056
    some values from: functioning process
  intersection of: Restriction
    on property: functionOf
    some values from: MaintainableMaterialItem
see also: ISO81346 for examples of functions
example: to sense, to store, to process information, to control
adapted from: The natural language definition is adapted from EN:13306
explanatory note: the function can be a combination of functions
first order logic axiom: RequiredFunction(x) ↔ Function(x) ∧ ∃y,z(MaintainableMaterialItem(y) ∧ FunctioningProcess(z) ∧ participatesInAtSomeTime(y,z) ∧ functionOf(x,y))
is primitive: true
natural language definition: function of a maintainable material item which is considered necessary to fulfil a process requirement
primitive rationale: no sufficient conditions are defined for this class
semi formal natural language axiom: every instance of 'required function' is defined as an instance of 'function' that is the 'function of' some 'maintainable material item' that 'participates in at some time' some 'functioning process'
synonym: primary function

supporting maintenance activity
type: Class
subclass of: PlannedProcess
example: activities that do not change the state of the asset but are done by maintenance personnel such as reporting activity, isolate activity, move activity, training activity
first order logic axiom: SupportingMaintenanceActivity(x) → PlannedProcess(x)
is primitive: true
natural language definition: single action in support of the execution of a maintenance process
primitive rationale: at this stage we do not have sufficient constructs to create necessary and sufficent conditions for this class.
semi formal natural language axiom: if x is a 'supporting maintenance activity' then x is a 'planned process'

undesireable disposition
type: Class
subclass of: BFO_0000016
equivalent class: Class
  union of: disposition to exhibit undesirable behavior
  union of: disposition to fail
example: disposition to leak, disposition to overheat, disposition to vibrate
explanatory note: There are two subclasses, disposition to fail and disposition to exhibit undesirable behavior. We need to distinguish between the disposition to leak which is realised in a leaking process (regarded as a failure) and the disposition to overheat realised in a heating process (which, in this example) is not a failure process). We asset that disposition to exhibit undesirable behavior is the disposition of an item that would not be expected under normal operating conditions but may occur such as vibration or overheating.
first order logic definition: UndesirableDisposition(x) ↔ DispositionToFail(x) ∨ DispositionToExhibitUndesirableBehavior(x)
is primitive: false
natural language definition: disposition of an item to undergo a process that leads to undesirable outcomes
semi formal natural language definition: every instance of 'undesirable disposition' is defined as exactly an instance of 'disposition to fail' or exactly an instance of 'disposition to exhibit undesirable behavior'
synonym: failure mode

has maintenance state
type: ObjectProperty
sub property of: BFO_0000056
domain: MaintainableMaterialItem
range: maintenance state
inverse of: maintenance state of
example: has partial function or loss of function
natural language definition: inverse of 'stateOf'

initiates
type: ObjectProperty
sub property of: BFO_0000063
domain: BFO_0000003
range: Class
  union of: BFO_0000015
  union of: Event
example: starts, begins, commences
natural language definition: comes before an event or process in time and results in beginning or creation of the event or process

maintenance state of
type: ObjectProperty
sub property of: BFO_0000167
domain: maintenance state
range: MaintainableMaterialItem
example: the physical or software asset
natural language definition: relation that describes the maintenance state of a maintainable item