Process Consistency Filter (PROF)

• Process Consistency Filter (PROF) is a consistency-checking layer for ontology-based models that uses formal parameter interdependencies to verify contextual data usage.
• It operates on an RDF graph that integrates standardized process semantics, OpenMath-RDF expressions, and explicit unit expectation mappings.
• The framework employs SPARQL filtering, unit checks, and recursive completeness verification to prevent semantic inconsistencies in manufacturing processes.

to=arxiv_search.search 五分彩 matters={"query":"(Jeleniewski et al., 19 Jun 2025)", "max_results": 5} to=arxiv_search.search 买天天中彩票 കാര്യहरू={"query":"ontology-based process models parameter interdependencies OpenMath-RDF units manufacturing", "max_results": 5} Process Consistency Filter (PROF) is a bundled consistency-checking layer for ontology-based process models enriched with formal parameter interdependencies. In the formulation given for manufacturing process knowledge, PROF operates on an RDF graph that integrates standardized process semantics, data element definitions, and OpenMath-RDF expressions, and it is designed to guarantee that only context-relevant data elements are used when instantiating generic mathematical relations in a given process step, to verify unit compatibility between variables and bound data elements, and to ensure that every mathematical output variable can actually be computed from available input data along recursive dependency chains (Jeleniewski et al., 19 Jun 2025).

1. Definition and objectives

PROF is defined over an RDF graph $G$ containing a set of process operators $P \subseteq G$ of type VDI3682:ProcessOperator, a set of interdependencies $F \subseteq G$ linked to process operators via ParX:hasInterdependency, and a set of variables $V \subseteq G$ of type OM:Variable, where each variable may be bound to zero or more data elements via ParX:isDataFor. In addition, PROF uses a mapping expectsUnit ⊆ V × U, where $U$ is the set of UNECE:Unit individuals, to capture the declared expected unit for each variable (Jeleniewski et al., 19 Jun 2025).

PROF succeeds on $G$ if and only if, for every process operator $p \in P$ and every interdependency $f$ linked to $p$, three conditions hold. First, all data elements bound to variables in $f$ must be context-relevant to $P \subseteq G$0. Second, for every variable with a bound data element, the actual unit of that data element must equal the declared expected unit. Third, every variable appearing in $P \subseteq G$1 must be bound to at least one context-relevant data element, and this requirement must also hold recursively for intermediate variables in nested OpenMath expressions (Jeleniewski et al., 19 Jun 2025).

The stated objectives are closely tied to the role of generic mathematical relations in manufacturing ontologies. Because such relations are often defined in reusable form and applied across multiple process contexts, the model must support correct data retrieval and correct interpretation. PROF addresses this requirement through explicit verification rather than by assuming that generic formula reuse is semantically safe (Jeleniewski et al., 19 Jun 2025).

2. Formal model and semantic foundations

In the underlying ontology-based process model, parameter interdependencies are represented as OpenMath-RDF graphs. Each interdependency $P \subseteq G$2 is an OM:Application node representing a mathematical operator such as CD:arith1/divide, with arguments linked via rdf:List structures to OM:Variable nodes. This representation allows mathematical structure to be encoded directly in the graph and queried together with process semantics and data-element metadata (Jeleniewski et al., 19 Jun 2025).

Unit verification is not performed by string comparison. Instead, data elements carry DINEN61360:has_Type_Description links to type descriptions that are subclasses of UNECE:Unit, while variables carry ParX:expectsUnit links to exactly one UNECE:Unit class. The logical axiom

$P \subseteq G$3

ensures that a variable declares an expected unit (Jeleniewski et al., 19 Jun 2025).

Context relevance is defined semantically rather than procedurally. A data element $P \subseteq G$4 is context-relevant to a process operator $P \subseteq G$5 if it is connected to $P \subseteq G$6 through any of the following structures: VDI3682:hasInput * DINEN61360:has_Data_Element, VDI3682:hasOutput * DINEN61360:has_Data_Element, VDI3682:isAssignedTo * DINEN61360:has_Data_Element, or DINEN61360:has_Data_Element directly. In the paper, this relation is described as an OWL property chain implicit in the SPARQL FILTER pattern used by PROF (Jeleniewski et al., 19 Jun 2025).

This combination of OpenMath-RDF, VDI/VDE 3682 process semantics, DIN EN 61360 data-element modeling, and UNECE unit classification is central to PROF. The framework is not merely a formula checker; it is a consistency layer over the joint semantic structure of process operators, variables, type descriptions, and mathematical dependencies (Jeleniewski et al., 19 Jun 2025).

3. Core verification mechanisms

PROF comprises three verification mechanisms: SPARQL-based filtering for context relevance, a unit consistency check, and a data completeness check (Jeleniewski et al., 19 Jun 2025).

The SPARQL-based filtering strategy addresses the fact that a generic formula may reference variables bound in multiple contexts, such as different tools or different process steps. Without a filter, a query may retrieve bindings from unrelated processes. PROF therefore uses a reusable FILTER EXISTS pattern that prunes data elements not reachable from a focal process operator. The pattern tests whether the queried data element is linked through outputs, inputs, assigned resources, or direct process-level data-element relations. This pattern is injected into any SPARQL query that retrieves data elements for variables, so that returned bindings are restricted to the specified process context (Jeleniewski et al., 19 Jun 2025).

The unit consistency check extends the ontology with ParX:expectsUnit links from OM:Variable to UNECE:Unit. For each variable $P \subseteq G$7, PROF compares the expected unit $P \subseteq G$8 against the actual unit class $P \subseteq G$9 of a bound data element’s type description. If $F \subseteq G$0, the system reports a consistency violation. The paper gives both a Datalog-like formulation and a SPARQL implementation that returns the variable, expected unit, actual type, and actual unit whenever a mismatch is detected (Jeleniewski et al., 19 Jun 2025).

The data completeness check validates computability. Its procedure begins by identifying a VDI3682:ProcessOperator and its output state, verifying that the output state is linked to one or more DINEN61360:DataElement instances, and checking that such a data element is linked via ParX:isDataFor to the result variable of the formula. PROF then recursively traverses the OM:arguments lists of the OpenMath expression to collect all OM:Variable nodes and verifies, for each of them, the existence of at least one context-relevant bound DataElement. Any returned (?process, ?missingVar) pair indicates that a required variable lacks a context-relevant data binding and that the interdependency cannot be evaluated in that process context (Jeleniewski et al., 19 Jun 2025).

Taken together, these mechanisms operationalize the three success conditions of PROF. Context filtering controls semantic scope, unit checking controls dimensional compatibility as modeled in the ontology, and completeness checking controls evaluability of the formula graph (Jeleniewski et al., 19 Jun 2025).

4. Mathematical expressions and recursive evaluability

A notable feature of PROF is that it treats parameter interdependencies as structured mathematical objects rather than opaque strings. In the described model, an interdependency is an OM:Application node whose operator and arguments can be traversed explicitly. This supports recursive verification of nested expressions, since input requirements are not confined to top-level variables but may arise in intermediate subexpressions reachable through OM:arguments and rdf:List structures (Jeleniewski et al., 19 Jun 2025).

The data completeness criterion is therefore stronger than a flat variable-presence check. PROF requires that every variable appearing in a formula be bound to at least one context-relevant data element, and that this requirement also hold recursively for any intermediate variables in nested OpenMath expressions. This matters in process models where output variables depend on formulas that invoke other mathematically structured components rather than simple one-level relations (Jeleniewski et al., 19 Jun 2025).

This formulation also clarifies the distinction between semantic validity and computational readiness. A process model may be ontologically well-formed and may contain a syntactically valid OpenMath expression, yet still fail PROF because the necessary bindings are absent in the focal process context, or because the retrieved bindings originate from a different context, or because their unit semantics do not match the formula’s declared expectations (Jeleniewski et al., 19 Jun 2025).

5. Resin Transfer Molding use case

The paper demonstrates PROF with a Resin Transfer Molding injection step ex:Injection, modeled using the fill-time formula

$F \subseteq G$1

In OpenMath-RDF, the expression is encoded by an OM:Application node A₁ with operator CD:relation1/eq, whose arguments are the numerator application A₂ and the result variable t; A₂ is an OM:Application with operator CD:arith1/divide and arguments [V_cavity, Q] (Jeleniewski et al., 19 Jun 2025).

The simplified data bindings are specified as follows: V_cavity is bound to ex:CavityVolume-A, whose DINEN61360:TypeDescription is UNECE:CMQ; Q is bound to ex:FlowOfMass-A, whose type is UNECE:2J; and t is bound to ex:FillTime_DE, whose type is UNECE:SEC. Expected units are declared with ParX:expectsUnit, specifically V_cavity expectsUnit UNECE:CMQ and Q expectsUnit UNECE:2J (Jeleniewski et al., 19 Jun 2025).

The contextual filtering example shows why the filter is required. A query over ?variable – ?dataElement without the context filter returns not only ex:CavityVolume-A and ex:FlowOfMass-A, but also ex:CavityVolume-B and ex:FlowOfMassHP-B from a different high-pressure injection step ex:InjectionHP. After injecting the context FILTER pattern with ?proc = ex:Injection, only the “-A” bindings remain (Jeleniewski et al., 19 Jun 2025).

The unit consistency example first reports that, for ex:Injection, all unit comparisons succeed, specifically cm³ vs. CMQ and cm³/s vs. 2J. An intentional error is then introduced by linking V_cavity to a data element typed as UNECE:LTR. In that case, the unit-mismatch query returns variable = ex:VCavity, expectedUnit = UNECE:CMQ, and actualUnit = UNECE:LTR, thereby identifying the semantic inconsistency (Jeleniewski et al., 19 Jun 2025).

The completeness example constructs a variant process ex:InjectionT with the same formula graph but without any dataElement → V_cavity binding. Executing the completeness query yields (ex:InjectionT, ex:VCavity), indicating that V_cavity is missing and that $F \subseteq G$2 cannot be computed (Jeleniewski et al., 19 Jun 2025).

6. Assumptions, limitations, and extensions

The approach is stated to rely on three assumptions. All interdependencies must be explicitly modeled in OpenMath-RDF form. Units of measurement must be available in DIN EN 61360 type descriptions classified under UNECE unit codes. The semantic structure of process operators must follow VDI/VDE 3682 (Jeleniewski et al., 19 Jun 2025).

Two limitations are identified explicitly. First, manual creation or import of formulas is required, so unknown relations must be formalized beforehand. Second, large knowledge graphs with deeply nested dependencies may incur performance bottlenecks in SPARQL queries (Jeleniewski et al., 19 Jun 2025).

The proposed extensions are framed in terms of portability and functional enrichment. For other manufacturing domains, the context-filter pattern can be adapted by substituting the VDI3682 patterns with other process modeling ontologies such as BPMN-OWL or OPC UA, thereby redefining what context relevance means in the target domain. The expected-unit mechanism can be extended to support automatic unit conversion by inferring conversions through a unit-of-measure ontology when actual and expected units differ but remain convertible. The paper also suggests integrating machine-learning-derived interdependencies by wrapping learned equations into OpenMath-RDF templates and then using PROF to verify contextual applicability and data readiness (Jeleniewski et al., 19 Jun 2025).

By embedding PROF at the ontology layer, the model provides an early warning system for wrong data contexts, unit mismatches, and missing parameters. In the stated formulation, this supports machine-interpretable, verifiable, and immediately usable engineering models for downstream calculation, simulation, and automated reasoning tasks (Jeleniewski et al., 19 Jun 2025).