Changes in 🟢 production planning ontology

Maturity: 🟢 Released
Previous Maturity: 🟡 Provisional

Maturity level has changed, review all classes in this ontology: 🟢 production planning ontology

Added

Classes

Construct	Definition
`ChangeoverProcess`	planned process that prepares a production resource to produce a different product or perform a different manufacturing operation
`Tool`	material artifact designed to be held, guided, or attached to help a person, machine, or mechanism perform a task
`WorkInProgressTransferProcess`	material location change process in which work in progress moves between production machines

Removed

Classes

Construct	Definition
`MachineTransferProcess`	A material location change process that involves moving work-in-progress parts between different machines.
`SetupProcess`	Setup process is a planned process where tools are attached between two manufactruing operations on the same resource (for example machine) such that the output of the first is different from the output of the second

Changed

Classes

`AgentialCapability`

IRI: https://spec.industrialontologies.org/ontology/construct/AgentialCapability

Annotations

firstOrderLogicDefinition = “∀x ( (Capability(x) ∧ ∃y (capabilityOf(x, y) ∧ Agent(y))) → AgentialCapability(x) )”

firstOrderLogicDefinition = “Capability(x) ∧ ∃y (Agent(y) ∧ capabilityOf(x, y)) → AgentialCapability(x)”

`InspectionPlan`

IRI: https://spec.industrialontologies.org/ontology/construct/InspectionPlan

Annotations

firstOrderLogicAxiom = “∀x ( (PlanSpecification(x) ∧ ∃y (prescribes(x, y) ∧ ProductInspectionProcess(y))) → InspectionPlan(x) )”
naturalLanguageDefinition = “Set of instructions specifying the process of verification including appropriate resources and sequence of inspections to be referenced by the manufacturing plan.”@en-US
semiFormalNaturalLanguageAxiom = “every instance of ‘inspection plan’ is defined as exactly an instance of ‘plan specification’ that ‘prescribes’ some ‘product inspection process’”

example = “incoming-material inspection procedure for steel coils; in-process dimensional inspection checklist for machined engine blocks; sampling and testing protocol for a pharmaceutical batch; final-product inspection plan for assembled pumps”@en-us
firstOrderLogicAxiom = “PlanSpecification(x) ∧ ∃y(prescribes(x,y) ∧ ProductInspectionProcess(y)) → InspectionPlan(x)”
naturalLanguageDefinition = “plan specification that prescribes how products are to be inspected, including the required resources and inspection sequence”@en-us
semiFormalNaturalLanguageAxiom = “if x is a ‘plan specification’ that ‘prescribes’ some ‘product inspection process’ then x is an ‘inspection plan’”

`Machine`

IRI: https://spec.industrialontologies.org/ontology/construct/Machine

Annotations

editorialNote = “There is a strong argument to move this class to IOF Core.”
naturalLanguageDefinition = “physical artefact or system that transforms energy or material through guided mechanical, electrical or fluid power for performing one or more processes.”
semiFormalNaturalLanguageDefinition = “if x is a machine then x is a physical artefact and x transforms energy or material through guided mechanical, electrical or fluid power in order to perform one or more processes”
subjectMatterExpertExplanation = “- “physical artefact” emphasises that the entity is a concrete built thing.
- “transforms energy or material” captures the notion of machines doing work (e.g., moving parts, powering machining, mixing, conveying).
- “guided mechanical, electrical or fluid power” property points at machine having power, motion, and control (mechanical structure + power source + actuation).
- “performing one or more processes” allows for generality (manufacturing, handling, processing, etc).”

example = “computer numerical control milling center; 250-ton hydraulic press; industrial ribbon blender; plastic injection-molding unit; centrifugal pump in a chemical-processing line, ventilator, CT scanner”@en-us
explanatoryNote = “- “physical artefact” emphasises that the entity is a concrete built thing.
- “transforms energy or material” captures the notion of machines doing work (e.g., moving parts, powering machining, mixing, conveying).
- “guided mechanical, electrical or fluid power” property points at machine having power, motion, and control (mechanical structure + power source + actuation).
- “performing one or more processes” allows for generality (manufacturing, handling, processing, etc).”
firstOrderLogicAxiom = “Machine(m) → MaterialArtifact(m)”
naturalLanguageDefinition = “material artifact that uses controlled mechanical, electrical, or fluid power to transform energy or material while performing a process”@en-us
semiFormalNaturalLanguageAxiom = “if x is a machine then x is a ‘material artifact’”

`ManufacturingEnterpriseProcess`

IRI: https://spec.industrialontologies.org/ontology/construct/ManufacturingEnterpriseProcess

Annotations

naturalLanguageDefinition = “business process that contains at least one manufacturing process”@en-US
primitiveRationale = “This term is included as an umbrella term for every kind processes which are not typically ‘business process’ but also cannot be classified as types of ‘manufacturing processes’ either. Although they contain manufacturing process as parts, and most of the time, the primary sub-process, the sub-types of this class groups or identity manufactruing processes and other anciliary processes for better organization, planning resources and raw materials, and sometimes scheduling and logistical management. Still, the question remains on the need of this class if the above criteria is hard to express formally.”

firstOrderLogicAxiom = “ManufacturingEnterpriseProcess(p) → ∃m(ManufacturingProcess(m) ∧ hasOccurrentPart(p,m))”
naturalLanguageDefinition = “business process that consists of at least one manufacturing process”@en-us
primitiveRationale = “This term is included as an umbrella term for every kind of process which is not typically ‘business process’ but also cannot be classified as types of ‘manufacturing processes’ either. Although they contain manufacturing process as parts, and most of the time, the primary sub-process, the sub-types of this class group or identify manufacturing processes and other ancillary processes for better organization, planning resources and raw materials, and sometimes scheduling and logistical management. Still, the question remains on the need of this class if the above criterion is hard to express formally.”
semiFormalNaturalLanguageAxiom = “if an entity is an instance of ‘manufacturing enterprise process’, then it ‘has occurrent part’ some instance of ‘manufacturing process’”

Parents

PlannedProcess (https://spec.industrialontologies.org/ontology/construct/PlannedProcess)

BusinessProcess (https://spec.industrialontologies.org/ontology/construct/BusinessProcess)

Axioms

SubClassOf: constr:PlannedProcess

SubClassOf: constr:BusinessProcess

`ManufacturingOperation`

IRI: https://spec.industrialontologies.org/ontology/construct/ManufacturingOperation

Annotations

firstOrderLogicAxiom = “∀o, x1, x2 ( ProcessStep(x1) ∧ ProcessStep(x2) ∧ ManufacturingOperation(o) ∧ occurrentPartOfAtSomeTime(x1, o) ∧ occurrentPartOfAtSomeTime(x2, o) ∧ (x1 ≠ x2) → ∃e, p1, p2, r1, r2 (ManufacturingProcess(p1) ∧ ManufacturingProcess(p2) ∧ occurrentPartOfAtSomeTime(p1, x1) ∧ occurrentPartOfAtSomeTime(p2, x2) ∧ hasParticipantAtSomeTimes(p1, e) ∧ hasParticipantAtSomeTimes(p2, e) ∧ hasRole(e, r1) ∧ hasRole(e, r2) ∧ EquipmentRole(r1) ∧ EquipmentRole(r2)))”
naturalLanguageDefinition = “Manufacturing enterprise process that aggregates only those process steps which are part of the same product production process and there exists at least one common manufacturing resource, used in the manufacturing process for each step.”@en-US
primitiveRationale = “The common grouping criteria cannot be formalized for this class and therefore only a necessary condition could be derived which does not check the “common resource for all step” condition. Furthermore, the use of operation in batch and continuous manufacturing many provide some more refinement on the role of the common participant.”
semiFormalNaturalLanguageAxiom = “if ‘x1’ and ‘x2’ are distinct ‘process steps’ that are ‘occurrent part of at some time’ the same ‘manufacturing operation’, then there exists some ‘equipment’ that ‘has role’ some ‘equipment role’ and that ‘has participant at some times’ both a ‘manufacturing process’ that is ‘occurrent part of at some time’ x1 and a ‘manufacturing process’ that is ‘occurrent part of at some time’ x2”

example = “hole making in an engine block consisting of centering, drilling, reaming, and finishing on one machining center; injection molding of a plastic housing consisting of mold closing, material injection, cooling, and part ejection”@en-us
firstOrderLogicAxiom = “LA1: ManufacturingOperation(o) → ManufacturingEnterpriseProcess(o) ∧ ∃m(MaterialEntity(m) ∧ hasParticipantAtSomeTime(o,m) ∧ ∃r((EquipmentRole(r) ∨ OperatorRole(r)) ∧ hasRole(m,r))) ∧ ∃s(ProcessStep(s) ∧ hasProperOccurrentPart(o,s))”
firstOrderLogicAxiom = “LA2: ProcessStep(x1) ∧ ProcessStep(x2) ∧ ManufacturingOperation(o) ∧ occurrentPartOfAtSomeTime(x1,o) ∧ occurrentPartOfAtSomeTime(x2,o) ∧ x1 ≠ x2 → ∃e,p1,p2,r1,r2(ManufacturingProcess(p1) ∧ ManufacturingProcess(p2) ∧ occurrentPartOfAtSomeTime(p1,x1) ∧ occurrentPartOfAtSomeTime(p2,x2) ∧ hasParticipantAtSomeTimes(p1,e) ∧ hasParticipantAtSomeTimes(p2,e) ∧ hasRole(e,r1) ∧ hasRole(e,r2) ∧ EquipmentRole(r1) ∧ EquipmentRole(r2))”
naturalLanguageDefinition = “manufacturing enterprise process composed of process steps from the same product production process, with at least one manufacturing resource used in every step”@en-us
primitiveRationale = “The common grouping criteria cannot be formalized for this class and therefore only a necessary condition could be derived which does not check the “common resource for all steps” condition. Furthermore, the use of operation in batch and continuous manufacturing may provide some more refinement on the role of the common participant.”
semiFormalNaturalLanguageAxiom = “LA1: if an entity is an instance of ‘manufacturing operation’, then it is an instance of ‘manufacturing enterprise process’, ‘has participant at some time’ some instance of ‘material entity’ that ‘has role’ some instance of ‘equipment role’ or ‘operator role’, and ‘has proper occurrent part’ some instance of ‘process step’”
semiFormalNaturalLanguageAxiom = “LA2: if two distinct instances of ‘process step’ are occurrent parts of a ‘manufacturing operation’ at some time, then there are instances of ‘manufacturing process’, each occurrent part of one of those process steps at some time, that have a common participant at some times; that participant ‘has role’ instances of ‘equipment role’ in both processe”

`MaterialHandlingPlan`

IRI: https://spec.industrialontologies.org/ontology/construct/MaterialHandlingPlan

Annotations

explanatoryNote = “The class is open to be further constrained by different kinds of material handling types. At this point only machine transfer process is included. The term can be overloaded by users with other general class axioms, e.g., some part of it describing the raw material sourcing process.

As the natural language suggests, planning in warehouse will require a more detailed characterization, this term needs to be shared between two modules by some upper level mapping, however such proposal are yet to be made.”
firstOrderLogicAxiom = “∀x (PlanSpecification(x) ∧ ∃y,z (prescribes(y, z) ∧ MachineTransferProcess(z)) ∧ hasContinuantPartAtAllTimes(x, y) → MaterialHandlingPlan(x))”
naturalLanguageDefinition = “A specification (PlanSpecification) that prescribes one or more material handling operations—sequences of actions, resource allocations, and constraints—designed to govern the efficient, safe, and controlled movement of materials or entities within production, storage, or distribution contexts.”@en-US

example = “batch-transfer schedule for moving chemicals from a reactor to a storage tank; warehouse picking and delivery instructions for supplying components to an assembly line; pallet-movement schedule for transporting finished products to shipping”@en-us
explanatoryNote = “A specification (PlanSpecification) that prescribes one or more material handling operations—sequences of actions, resource allocations, and constraints—designed to govern the efficient, safe, and controlled movement of materials or entities within production, storage, or distribution contexts.

The class is open to be further constrained by different kinds of material handling types. At this point only machine transfer process is included. The term can be overloaded by users with other general class axioms, e.g., some part of it describing the raw material sourcing process.

As the natural language suggests, planning in warehouse will require a more detailed characterization, this term needs to be shared between two modules by some upper level mapping, however such proposal are yet to be made.”
firstOrderLogicAxiom = “PlanSpecification(x) ∧ ∃y,z (prescribes(y, z) ∧ MachineTransferProcess(z)) ∧ hasContinuantPartAtAllTimes(x, y) → MaterialHandlingPlan(x)”
naturalLanguageDefinition = “plan specification containing instructions that prescribe the movement of material between production machines”@en-us

Axioms

constr:PlanSpecification and bfo:has_continuant_part_at_all_times some constr:prescribes some constr:MachineTransferProcess SubClassOf: constr:MaterialHandlingPlan

constr:PlanSpecification and bfo:has_continuant_part_at_all_times some constr:prescribes some constr:WorkInProgressTransferProcess SubClassOf: constr:MaterialHandlingPlan

`MaterialProductSpecification`

IRI: https://spec.industrialontologies.org/ontology/construct/MaterialProductSpecification

Annotations

firstOrderLogicAxiom = “MaterialProductSpecification(x) ↔ DesignSpecification(x) ∧ ∃y (prescribes(x, y) ∧ MaterialProduct(y))”
naturalLanguageDefinition = “A design specification containing the structure, dimension, and other characteristics of a product that satisfies the requirement of a purchase order from a customer.”@en-US

example = “engineering drawing specifying the geometry and tolerances of an aluminum bracket; technical data sheet defining the composition and properties of a polymer resin; formulation and packaging requirements for an industrial coating; product specification requiring a tablet mass of 650 ± 10 milligrams”@en-us
firstOrderLogicAxiom = “DesignSpecification(d) ∧ ∃m(MaterialProduct(m) ∧ prescribes(d,m)) → MaterialProductSpecification(d)”
firstOrderLogicDefinition = “MaterialProductSpecification(x) → DesignSpecification(x) ∧ ∀y (prescribes(x, y) → MaterialProduct(y))”
naturalLanguageDefinition = “design specification that prescribes a material product”@en-us
semiFormalNaturalLanguageAxiom = “if an instance of ‘design specification’ ‘prescribes’ some instance of ‘material product’, then it is an instance of ‘material product specification’”

Axioms

EquivalentTo: constr:DesignSpecification and constr:prescribes only constr:MaterialProduct
SubClassOf: constr:DesignSpecification

SubClassOf: constr:DesignSpecification and constr:prescribes only constr:MaterialProduct
SubClassOf: owl:Thing

`OperationSpecification`

IRI: https://spec.industrialontologies.org/ontology/construct/OperationSpecification

Annotations

explanatoryNote = “This part of the plan specifies one or many steps, each of which are to be performed using one or more specific manufacturing resource or parallely or consecutively.”
firstOrderLogicDefinition = “ActionSpecification(x) ∧ ∃y (ManufacturingOperation(y) ∧ prescribes(x,y)) → OperationSpecification(x)”
naturalLanguageDefinition = “An action specification that prescribes some manufacturing operation.”@en-US
semiFormalNaturalLanguageDefinition = “If x is an ‘action specification’ and there exists a ‘manufacturing operation’ y that is ‘prescribed by’ x then x is an ‘operation specification’.”

example = “machining work instruction specifying centering, drilling, reaming, and hole finishing; injection-molding instruction specifying mold closing, polymer injection, cooling, and part ejection, NC Program for machining a part on a lathe”@en-us
explanatoryNote = “This part of the plan specifies one or many steps, each of which is to be performed using one or more specific manufacturing resource in parallel or consecutively.”
firstOrderLogicAxiom = “LA1: OperationSpecification(o) ∧ hasContinuantPartAtAllTimes(o,p) → ¬ProcessPlan(p) ∧ ¬ProductionPlan(p)”
firstOrderLogicAxiom = “LA2: OperationSpecification(o) ∧ hasProperContinuantPartAtAllTimes(o,o’) → ¬OperationSpecification(o’)”
firstOrderLogicAxiom = “LA3: ActionSpecification(o) ∧ ∃s(ProcessStepSpecification(s) ∧ hasContinuantPartAtAllTimes(o,s)) ∧ ∃p(ManufacturingOperation(p) ∧ prescribes(o,p)) → OperationSpecification(o)”
naturalLanguageDefinition = “action specification that prescribes a manufacturing operation and includes specifications for its process steps”@en-us
semiFormalNaturalLanguageAxiom = “LA1: if an instance of ‘operation specification’ ‘has continuant part at all times’ an entity, then that entity is neither an instance of ‘process plan’ nor an instance of ‘production plan’”
semiFormalNaturalLanguageAxiom = “LA2: if an instance of ‘operation specification’ ‘has proper continuant part at all times’ an entity, then that entity is not an instance of ‘operation specification’”
semiFormalNaturalLanguageAxiom = “LA3: if an instance of ‘action specification’ ‘has continuant part at all times’ some instance of ‘process step specification’ and ‘prescribes’ some instance of ‘manufacturing operation’, then it is an instance of ‘operation specification’”

Axioms

constr:ActionSpecification and constr:prescribes some constr:ManufacturingOperation SubClassOf: constr:OperationSpecification

SubClassOf: bfo:has_continuant_part_at_all_times only not (constr:ProcessPlan or constr:ProductionPlan)
SubClassOf: bfo:has_proper_continuant_part_at_all_times only not constr:OperationSpecification
constr:ActionSpecification and bfo:has_continuant_part_at_all_times some constr:ProcessStepSpecification and constr:prescribes some constr:ManufacturingOperation SubClassOf: constr:OperationSpecification

`Operator`

IRI: https://spec.industrialontologies.org/ontology/construct/Operator

Annotations

firstOrderLogicDefinition = “Agent(x) ∧ ∃y (OperatorRole(y) ∧ hasRole(x, y))”
naturalLanguageDefinition = “person or organization which has an operator role”@en-US
semiFormalNaturalLanguageDefinition = “x is an ‘agent’ that ‘has role’ some ‘operator role’”

example = “machinist running a CNC milling machine; technician monitoring a chemical reactor; production worker controlling an automated packaging line; utility company operating an industrial wastewater-treatment facility”@en-us
firstOrderLogicDefinition = “Operator(x) ↔ Agent(x) ∧ ∃y (OperatorRole(y) ∧ hasRole(x, y))”
naturalLanguageDefinition = “agent which has an operator role”@en-us
semiFormalNaturalLanguageDefinition = “every instance of ‘operator’ is defined as exactly an instance of ‘agent’ that ‘has role’ some ‘operator role’”

`OperatorRole`

IRI: https://spec.industrialontologies.org/ontology/construct/OperatorRole

Annotations

example = “person as a CNC operator has an operator role of operating, mantaining, and utilizing the assigned CNC machine before, during, and after a manufacturing process”@en-US
firstOrderLogicAxiom = “AgentRole(x) ∧ ∃a (Agent(a) ∧ roleOf(x, a) ∧ participatesIn(a, p) ∧ ManufacturingProcess(p)) → OperatorRole(x)”
firstOrderLogicDefinition = “AgentRole(x) → Role(x) ∧ ∃a ∃s ∃c ∃e ( Agent(a) ∧ roleOf(x,a) ∧ skill(s) ∧ hasCapability(a,s) ∧ Capability(c) ∧ PieceOfEquipment(e) ∧ capabilityOf(c,e) ∧ enables(s,c))”
naturalLanguageDefinition = “role held by an agent when it possesses a skill that enables a capability of a piece of equipment.”@en-US
semiFormalNaturalLanguageAxiom = “if x is an ‘agent role’ that is the ‘role of’ some ‘agent’ who ‘participates in’ a ‘manufacturing process’, then x is an ‘operator role’”
semiFormalNaturalLanguageDefinition = “if x is an ‘agent role’, then x is a ‘role’ that is the ‘role of’ some ‘agent’ who ‘has capability’ some ‘skill’ s, and s ‘enables’ some ‘capability’ c that is the ‘capability of’ some ‘piece of equipment’ e.”

example = “person as a CNC operator has an operator role of operating, maintaining, and utilizing the assigned CNC machine before, during, and after a manufacturing process”@en-us
explanatoryNote = “1. Relevant skills may enable a capability of a single piece of equipment or the coordinated realization of capabilities of multiple pieces of equipment, such as those operating together in a process cell or production line
1. In this definition, enabling an equipment capability is not limited to directly operating the equipment. A skill may enable the realization of an equipment capability by allowing the agent to set up, start, stop, monitor, adjust, or otherwise use the equipment; monitor and control a process through the equipment; coordinate multiple pieces of equipment; interpret equipment states, process conditions, alarms, and outputs; respond to normal or abnormal conditions; inspect or assess equipment condition or performance; or perform operator-level cleaning, troubleshooting, or routine maintenance. Relevant skills may also include those needed to apply applicable quality, occupational safety, process safety, biosafety, hygiene, contamination-control, environmental, or other domain-specific requirements.”
firstOrderLogicAxiom = “OperatorRole(r) → AgentRole(r) ∧ ∃g(Agent(g) ∧ roleOf(r,g) ∧ ∃c(AgentialCapability(c) ∧ hasCapability(g,c) ∧ ∃x(enables(c,x) ∧ ∃e(PieceOfEquipment(e) ∧ capabilityOf(x,e)))))”
naturalLanguageDefinition = “role held by an agent when it possesses a skill that enables a capability of one or more pieces of equipment.”@en-us
semiFormalNaturalLanguageAxiom = “For every instance of ‘operator role’, there exists an instance of ‘agent role’ that ‘is role of’ some instance of ‘agent’ that ‘has capability’ some instance of ‘agential capability’ that ‘enables’ some capability that ‘is capability of’ some instance of ‘piece of equipment’”

Axioms

EquivalentTo: constr:AgentRole and constr:roleOf some (constr:Agent and constr:hasCapability some (constr:AgentialCapability and constr:enables some constr:capabilityOf some constr:PieceOfEquipment))
constr:AgentRole and constr:roleOf some (constr:Agent and bfo:participates_in_at_some_time some constr:ManufacturingProcess) SubClassOf: constr:OperatorRole

SubClassOf: constr:roleOf some (constr:Agent and constr:hasCapability some (constr:AgentialCapability and constr:enables some constr:capabilityOf some constr:PieceOfEquipment))

`ProcessPlan`

IRI: https://spec.industrialontologies.org/ontology/construct/ProcessPlan

Annotations

firstOrderLogicAxiom = “PlanSpecification(x) ∧ ∃y(prescribes(x,y) ∧ ProductProductionProcess(y)) → ProcessPlan(x)”
firstOrderLogicDefinition = “ProcessPlan(x) ↔ PlanSpecification(x) ∧ ∀y ((continuantPartAtAllTimes(y, x) ∧ ObjectiveSpecification(y)) → ProductionOrder(y)) ∧ ∀z ((continuantPartAtAllTimes(z, x) ∧ ActionSpecification(z)) → (OperationSpecification(z) ∨ ProcessSpecification(z)))”
naturalLanguageDefinition = “Plan which include steps and sequence required to produce a product at the required quality level and cost.”@en-US
semiFormalNaturalLanguageAxiom = “x is a ‘plan specification’ if and only if x prescribes a ‘product production process’ then x is a ‘process plan’.”
semiFormalNaturalLanguageDefinition = “If x is ‘process plan’ then x is a ‘plan specification’ and every ‘objective specification’ which is a continuant part of x is a ‘production order’, and every ‘action specification’, which is a continuant part of x is either a ‘operation specification’ or ‘process specification’.”

firstOrderLogicAxiom = “LA1: ProcessPlan(p) ∧ hasProperContinuantPartAtAllTimes(p,p’) → ¬ProcessPlan(p’)”
firstOrderLogicAxiom = “LA2: ProcessPlan(p) ∧ hasContinuantPartAtAllTimes(p,x) → ¬ProductionPlan(x)”
firstOrderLogicAxiom = “LA3: PlanSpecification(p) ∧ ∃s((OperationSpecification(s) ∨ ProcessStepSpecification(s)) ∧ hasContinuantPartAtAllTimes(p,s)) ∧ ∃o(ProductProductionProcess(o) ∧ prescribes(p,o)) → ProcessPlan(p)”
firstOrderLogicDefinition = “ProcessPlan(p) ↔ PlanSpecification(p) ∧ ∃o(ObjectiveSpecification(o) ∧ hasProperContinuantPartAtAllTimes(p,o) ∧ ∃m(MaterialProductSpecification(m) ∧ hasContinuantPartAtAllTimes(o,m))) ∧ ∃p’(ProductionPlan(p’) ∧ properContinuantPartOfAtAllTimes(p,p’))”
naturalLanguageDefinition = “plan specification that prescribes a product production process and includes specifications for its operations or process steps”@en-us
semiFormalNaturalLanguageAxiom = “LA1: if p is an instance of ‘process plan’ and p ‘has proper continuant part at all times’ p’, then p’ is not an instance of ‘process plan’”
semiFormalNaturalLanguageAxiom = “LA2: if p is an instance of ‘process plan’ and p ‘has continuant part at all times’ x, then x is not an instance of ‘production plan’”
semiFormalNaturalLanguageAxiom = “LA3: if an instance of ‘plan specification’ ‘has continuant part at all times’ some instance of ‘operation specification’ or ‘process step specification’ and ‘prescribes’ some instance of ‘product production process’, then it is an instance of ‘process plan’”
semiFormalNaturalLanguageDefinition = “every instance of ‘process plan’ is defined as exactly an instance of ‘plan specification’ that ‘has proper continuant part at all times’ some ‘objective specification’ that ‘has continuant part at all times’ some ‘material product specification’, and that is ‘proper continuant part of at all times’ some ‘production plan’”

Axioms

EquivalentTo: constr:PlanSpecification and bfo:has_proper_continuant_part_at_all_times only (constr:ObjectiveSpecification and bfo:has_continuant_part_at_all_times some constr:MaterialProductSpecification) and bfo:has_proper_continuant_part_at_all_times only (constr:OperationSpecification or constr:ProcessStepSpecification)
constr:PlanSpecification and constr:prescribes some bfo:occurrent_part_of some constr:ProductProductionProcess SubClassOf: constr:ProcessPlan

EquivalentTo: constr:PlanSpecification and bfo:has_proper_continuant_part_at_all_times some (constr:ObjectiveSpecification and bfo:has_continuant_part_at_all_times some constr:MaterialProductSpecification) and bfo:proper_continuant_part_of_at_all_times some constr:ProductionPlan
SubClassOf: bfo:has_continuant_part_at_all_times only not constr:ProductionPlan
SubClassOf: bfo:has_proper_continuant_part_at_all_times only not constr:ProcessPlan
constr:PlanSpecification and bfo:has_continuant_part_at_all_times some (constr:OperationSpecification or constr:ProcessStepSpecification) and constr:prescribes some constr:ProductProductionProcess SubClassOf: constr:ProcessPlan

`ProcessStep`

IRI: https://spec.industrialontologies.org/ontology/construct/ProcessStep

Annotations

firstOrderLogicDefinition = “processStep(x) ↔ ManufacturingEnterpriseProcess(x) ∧ ∃p (ManufacturingProcess(p) ∧ occurrentPartOfAtSomeTime(p,x)) ∧ ∀s ((processStep(s) ∧ occurrentPartOfAtSomeTime(s,x)) → (s = x))”
naturalLanguageDefinition = “A unit subprocess of an operation which does not contain any other process step and exactly one manufacturing process as a subprocess.”@en-US
semiFormalNaturalLanguageDefinition = “every instance of ‘process step’ is defined as exactly an instance of ‘manufacturing enterprise process’ that has at least one ‘manufacturing process’ as an ‘occurrent part at some time’ and does not have any other ‘process step’ as an ‘occurrent part at some time’.”

firstOrderLogicAxiom = “ProcessStep(x) → ManufacturingEnterpriseProcess(x) ∧ ∃p(ManufacturingProcess(p) ∧ occurrentPartOfAtSomeTime(p,x)) ∧ ∀s((ProcessStep(s) ∧ occurrentPartOfAtSomeTime(s,x)) → s = x)”
naturalLanguageDefinition = “manufacturing enterprise process within a manufacturing operation that contains one manufacturing process and no smaller process steps”@en-us
semiFormalNaturalLanguageAxiom = “if an entity is an instance of ‘process step’, then it is an instance of ‘manufacturing enterprise process’, has some instance of ‘manufacturing process’ as an occurrent part at some time, and every instance of ‘process step’ that is an occurrent part of it at some time is identical to it”

`ProcessStepSpecification`

IRI: https://spec.industrialontologies.org/ontology/construct/ProcessStepSpecification

Annotations

firstOrderLogicAxiom = “ActionSpecification(x) ∧ ∃y (ProcessStep(y)∧prescribes(x,y)) → ProcessSpecification(x)”
naturalLanguageDefinition = “An action specification that prescribes some process steps.”@en-US
semiFormalNaturalLanguageAxiom = “If x is an ‘action specifciation’ and there exists a ‘process step’ y that is ‘prescribed by’ x then x is an ‘process specification’.”

example = “drilling instruction requiring a 10-millimeter hole to be drilled to a depth of 20 millimeters; mixing instruction requiring a chemical batch to be agitated at 60 revolutions per minute for 10 minutes”@en-us
firstOrderLogicAxiom = “LA1: ProcessStepSpecification(s) ∧ hasContinuantPartAtAllTimes(s,x) → ¬ProcessPlan(x) ∧ ¬ProductionPlan(x) ∧ ¬OperationSpecification(x)”
firstOrderLogicAxiom = “LA2: ProcessStepSpecification(s) ∧ hasProperContinuantPartAtAllTimes(s,s’) → ¬ProcessStepSpecification(s’)”
firstOrderLogicAxiom = “LA3: ActionSpecification(s) ∧ ∃p(ProcessStep(p) ∧ prescribes(s,p)) → ProcessStepSpecification(s)”
naturalLanguageDefinition = “action specification that prescribes some process step”@en-us
semiFormalNaturalLanguageAxiom = “LA1: if an instance of ‘process step specification’ ‘has continuant part at all times’ an entity, then that entity is not an instance of ‘process plan’, ‘production plan’, or ‘operation specification’”
semiFormalNaturalLanguageAxiom = “LA2: if an instance of ‘process step specification’ ‘has proper continuant part at all times’ an entity, then that entity is not an instance of ‘process step specification’”
semiFormalNaturalLanguageAxiom = “LA3: if an instance of ‘action specification’ ‘prescribes’ some instance of ‘process step’, then it is an instance of ‘process step specification’”

Axioms

SubClassOf: bfo:has_continuant_part_at_all_times only not (constr:OperationSpecification or constr:ProcessPlan or constr:ProductionPlan)
SubClassOf: bfo:has_proper_continuant_part_at_all_times only not constr:ProcessStepSpecification

`ProductInspectionProcess`

IRI: https://spec.industrialontologies.org/ontology/construct/ProductInspectionProcess

Annotations

firstOrderLogicAxiom = “LA1: ∀x (PlanSpecification(x) ∧ ∃y (ProductInspectionProcess(y) ∧ prescribes(x, y)) → InspectionPlan(x))”
naturalLanguageDefinition = “Product inspection is a systematic process of evaluating goods during and after production to ensure they meet specified quality standards.”@en-US
semiFormalNaturalLanguageDefinition = “if x is an instance of ‘plan specification’ that ‘prescribes’ some ‘product inspection process’, then x is an instance of ‘inspection plan’”@en-US

firstOrderLogicAxiom = “ProductInspectionProcess(x) → BusinessProcess(x)”
naturalLanguageDefinition = “business process that evaluates a product during or after production against specified requirements”@en-us
semiFormalNaturalLanguageAxiom = “if an entity is an instance of ‘product inspection process’, then it is an instance of ‘business process’”

`ProductionMachine`

IRI: https://spec.industrialontologies.org/ontology/construct/ProductionMachine

Annotations

firstOrderLogicAxiom = “∀x (Machine(x) ∧ ∃r (hasRole(x, r) ∧ EquipmentRole(r) ∧ ∀p (realizes(p, r) → ManufacturingProcess(p))) → EquipmentMachine(x))”
naturalLanguageDefinition = “machine that are used in manufacturing process as equipments.”@en-US

firstOrderLogicAxiom = “Machine(x) ∧ ∃r (hasRole(x, r) ∧ EquipmentRole(r) ∧ ∀p (realizes(p, r) → ManufacturingProcess(p))) → EquipmentMachine(x)”
naturalLanguageDefinition = “machine used as equipment in a manufacturing process”@en-us

`ProductionOrder`

IRI: https://spec.industrialontologies.org/ontology/construct/ProductionOrder

Annotations

firstOrderLogicAxiom = “ObjectiveSpecification(x) ∧ ∃y (isAchievedByAtSomeTime(x, y) ∧ ProductProductionProcess(y)) → ProductionOrder(x)”
firstOrderLogicDefinition = “ProductionOrder(x) ↔ ObjectiveSpecification(x) ∧ ∃y (MaterialProductSpecification(y) ∧ hasContinuantPartAtAllTimes(x, y))”
naturalLanguageDefinition = “A production order is a document that states the number of units to be manufactured, the date when the order is released for production, and where the units should be delivered once they have been completed. A production order may be triggered by a long-term plan to maintain certain inventory levels, or by the receipt of an order from a customer.”@en-US
semiFormalNaturalLanguageAxiom = “If x is an ‘objective specification’ and there exists a ‘product production process’ y that x is achieved by at some time, then x is a ‘production order’.”
semiFormalNaturalLanguageDefinition = “x is a ‘production order’ if and only if x ‘has continuant part at all times’ some y which is a ‘material product specification’.”

firstOrderLogicAxiom = “LA1: ProductionOrder(o) → (ObjectiveSpecification(o) ∧ ∃m(MaterialProductSpecification(m) ∧ hasContinuantPartAtAllTimes(o,m)))”
firstOrderLogicAxiom = “LA2: ObjectiveSpecification(o) ∧ ∃p(PlannedProcess(p) ∧ isAchievedByAtSomeTime(o,p) ∧ ∃q(ProductProductionProcess(q) ∧ hasOccurrentPart(p,q))) → ProductionOrder(o)”
naturalLanguageDefinition = “objective specification stating the product and quantity to be produced and any applicable release, completion, or delivery requirements”@en-us
semiFormalNaturalLanguageAxiom = “LA1: if an entity is an instance of ‘production order’, then it is an instance of ‘objective specification’ and ‘has continuant part at all times’ some instance of ‘material product specification’”
semiFormalNaturalLanguageAxiom = “LA2: if an instance of ‘objective specification’ ‘is achieved by at some time’ some instance of ‘planned process’ that ‘has occurrent part’ some instance of ‘product production process’, then it is an instance of ‘production order’”

Axioms

constr:ObjectiveSpecification and constr:isAchievedByAtSomeTime some constr:ProductProductionProcess SubClassOf: constr:ProductionOrder

constr:ObjectiveSpecification and constr:isAchievedByAtSomeTime some (constr:PlannedProcess and bfo:has_occurrent_part some constr:ProductProductionProcess) SubClassOf: constr:ProductionOrder

`ProductionPlan`

IRI: https://spec.industrialontologies.org/ontology/construct/ProductionPlan

Annotations

firstOrderLogicAxiom = “PlanSpecification(x) ∧ ∃y(prescribes(x,y) ∧ ProductProductionProcess(y)) → ProductionPlan(x)”
firstOrderLogicDefinition = “ProductionPlan(x) ↔ PlanSpecification(x) ∧ ∀y (continuantPartAtAllTimes(y,x) ∧ ObjectiveSpecification(y)) → ProductionOrder(y)) ∧ ∀z (continuantPartAtAllTimes(z,x) ∧ PlanSpecification(z) → (ProcessPlan(z) V InspectionPlan(z) V MaterialHandlingPlan(z)))”
naturalLanguageDefinition = “Plan that aims at producing one or multiple products as specified or fulfills some production order.”@en-US
semiFormalNaturalLanguageAxiom = “x is a ‘plan specifcation’ if and only if x prescribes a ‘product production process’ then x is a ‘production plan’.”
semiFormalNaturalLanguageDefinition = “A production plan is a type of plan specification that has as continuant parts, at all times, at least one objective specification that is a production order, and any continuant part that is a plan specification must be either a process plan, an inspection plan, or a material handling plan”

firstOrderLogicAxiom = “LA1: ProductionPlan(p) ∧ hasProperContinuantPartAtSomeTime(p,p’) → ¬ProductionPlan(p’)”
firstOrderLogicAxiom = “LA2: PlanSpecification(p) ∧ ∃q(PlannedProcess(q) ∧ prescribes(p,q) ∧ ∃o(ProductProductionProcess(o) ∧ hasOccurrentPart(q,o))) → ProductionPlan(p)”
firstOrderLogicDefinition = “ProductionPlan(p) ↔ PlanSpecification(p) ∧ ∃o(ProductionOrder(o) ∧ hasProperContinuantPartAtAllTimes(p,o))”
naturalLanguageDefinition = “plan specification that contains a set of production orders and prescribes how they are to be fulfilled”@en-us
semiFormalNaturalLanguageAxiom = “LA1: if p is an instance of ‘production plan’ and p ‘has proper continuant part at some time’ p’, then p’ is not an instance of ‘production plan’”
semiFormalNaturalLanguageAxiom = “LA2: if an instance of ‘plan specification’ ‘prescribes’ some instance of ‘planned process’ that ‘has occurrent part’ some instance of ‘product production process’, then it is an instance of ‘production plan’”
semiFormalNaturalLanguageDefinition = “every instance of ‘production plan’ is defined as exactly an instance of ‘plan specification’ that ‘has proper continuant part at all times’ some instance of ‘production order’”

Axioms

EquivalentTo: constr:PlanSpecification and bfo:has_continuant_part_at_all_times only (constr:InspectionPlan or constr:MaterialHandlingPlan or constr:ProcessPlan) and bfo:has_proper_continuant_part_at_all_times only constr:ProductionOrder
constr:PlanSpecification and constr:prescribes some constr:ProductProductionProcess SubClassOf: constr:ProductionPlan

EquivalentTo: constr:PlanSpecification and bfo:has_proper_continuant_part_at_all_times some constr:ProductionOrder
SubClassOf: bfo:has_proper_continuant_part_at_some_time only not constr:ProductionPlan
constr:PlanSpecification and bfo:has_continuant_part_at_all_times some constr:ProcessPlan and constr:prescribes some (constr:PlannedProcess and bfo:has_occurrent_part some constr:ProductProductionProcess) SubClassOf: constr:ProductionPlan

`ProductionTool`

IRI: https://spec.industrialontologies.org/ontology/construct/ProductionTool

Annotations

naturalLanguageDefinition = “physical artefact designed to be held, guided or affixed to facilitate execution of a task by a human, machine or mechanism.”
semiFormalNaturalLanguageDefinition = “if x is a tool then x is a physical artefact and x is designed to be held, guided or affixed by a human, machine or mechanism to facilitate execution of a task”
subjectMatterExpertExplanation = “- “designed to be held, guided or affixed” distinguishes tools from machines: often simpler, may require manual or machine guidance.
- “facilitate execution of a task” covers uses ranging from hand‑tools (hammer, wrench) to machine‑tools (cutting insert, fixture) in the broader sense.
- By stating “by a human, machine or mechanism,” the definition remains flexible to tools used both manually and in automated contexts.”

example = “carbide insert 1/2 in end mill tool; stamping die for Toyota hood panel; dough-cutting die producing 50 portions per minute”@en-us
explanatoryNote = “- “designed to be held, guided or affixed” distinguishes tools from machines: often simpler, may require manual or machine guidance.
- “facilitate execution of a task” covers uses ranging from hand‑tools (hammer, wrench) to machine‑tools (cutting insert, fixture) in the broader sense.
- By stating “by a human, machine or mechanism,” the definition remains flexible to tools used both manually and in automated contexts.”
firstOrderLogicAxiom = “ProductionTool(t) → ∃r(EquipmentRole(r) ∧ hasRole(t,r) ∧ ∀p(hasRealization(r,p) → ManufacturingProcess(p)))”
naturalLanguageDefinition = “tool designed to be held, guided or affixed to enable execution of a manufacturing process”@en-us
semiFormalNaturalLanguageAxiom = “if an entity is an instance of ‘production tool’, then it ‘has role’ some instance of ‘equipment role’ that ‘has realization’ only instances of ‘manufacturing process’”

Parents

MaterialArtifact (https://spec.industrialontologies.org/ontology/construct/MaterialArtifact)

Tool (https://spec.industrialontologies.org/ontology/construct/Tool)

Axioms

SubClassOf: constr:MaterialArtifact

SubClassOf: constr:Tool

Object Properties

`enabledBy`

IRI: https://spec.industrialontologies.org/ontology/construct/enabledBy

Annotations

naturalLanguageDefinition = “capability enabled by another capability implies the second capability enables the first capability.”

example = “the hole-making capability of a drilling machine is enabled by the cutting capability of the drill bit installed in the machine”@en-us
naturalLanguageDefinition = “relation from one capability to another capability such that associated performance of the first capability is made possible by another”@en-us

`enables`

IRI: https://spec.industrialontologies.org/ontology/construct/enables

Annotations

firstOrderLogicDefinition = “enables(c1, c2) → ∃p1 ∃p2 ((realizes(p1, c1) → realizes(p2, c2)) ∨ (realizes(p2, c2) → realizes(p1, c1)))”
naturalLanguageDefinition = “capability enables another capability implies that either the realization of the first capability implies the realization of the second capability or the realization of the second capability implies the realization of the first capability.”@en-US

example = “the cutting capability of an installed drill bit enables the hole-making capability of a drilling machine”@en-us
firstOrderLogicDefinition = “enables(c1, c2) → ∀p1 (realizes(p1, c1) → ∃p2 realizes(p2, c2))”
naturalLanguageDefinition = “a capability enables another capability only if realization of the first capability implies realization of the second capability”@en-us