Assembly sequence planners require information such as eligible assembly sequences and constraints to generate feasible assembly plans. This information can be, for example, encoded in the form of a precedence matrix. This paper presents a knowledge-driven approach that integrates ontological reasoning with geometry and topology-aware properties to systematically generate precedence matrices. We use a bottom-up assembly approach to generate ontological reasoning rules by identifying an initial part and then successively attaching directly connected components until the entire assembly is complete. We implement an ontology-based reasoning framework in which Semantic Web Language rules encode and enforce priority relationships among parts based on their direct connectivity and assembly constraints. Each rule captures a specific precedence condition. We validate the correctness and generality of these rules by applying them to multiple, structurally diverse products. The reasoning mechanism reliably infers sound precedence constraints for each evaluated assembly, producing a correct partial order of operations from which valid assembly or disassembly sequences can be generated.
In this category, precedence constraints are derived directly from the CAD geometry through algorithmic collision, stability, or physics-engine simulation, without relying on human-demonstrated trajectories.
Collision or interference tests are the classic starting point. A candidate component is “virtually removed”
along its assembly direction while all other components remain fixed; any interference identifies a
blocker and therefore a precedence relation. Early sweep-test pipelines such as Zhang et al. (2017)
building an interference matrix by collision-detection use bounding-volume and facet-intersection tests
to identify colliding part pairs and filter out spurious geometry [
Although collision analysis pipelines ofer fully automated precedence extraction by simulating part motions and recording physical interferences to find “must-precede” relations, their capabilities are limited by an exclusive reliance on geometric interference detection. Specifically, they overlook semantically rich CAD-defined connection types — such as coincident, concentric, threaded, and gear-to-gear relationships — which are critical for capturing assembly-relevant dependencies.
Ontology-based methods represent one of the most promising recent advances in systematically
generating precedence matrices. Ontologies provide structured semantic frameworks to formally represent
assembly knowledge, capturing both physical relationships such as spatial constraints and functional
relationships such as load-bearing constraints. Using ontologies, precedence constraints are inferred by
applying semantic rules through reasoners, often encoded using languages such as OWL (Web Ontology
Language) and SWRL (Semantic Web Rule Language) [
Hu et al. (2024) [
Qian et al. (2020) [
While collision-based pipelines excel at detecting geometric clashes, yet they remain essentially syntactic: a collision flag explains that two parts cannot move simultaneously, but not why one part should precede the other in the product’s functional logic. Our objective is to unify these two strands – precision geometry and explicit semantics – into a single, fully automated workflow that (i) lifts low-level CAD features to function-aware relations and (ii) exploits those relations to systematically generate precedence matrices for assembly processes. In summary, our work makes the following contributions: 1. Product-agnostic derivation of precedence matrix. We introduce a generic method that derives a precedence matrix directly from CAD data. The procedure employs OWL/SWRL semantics and class-level rules, avoiding bill of material (BOM)-specific hard-coding and enabling seamless application across a broad spectrum of assemblies. 2. Automatic extraction of concentric and coincident relationships from native STEP. We develop a geometric parser that detects directly concentric (cylindrical) and the inference of coincident (planar) connections from STEP files. 3. Ontology-based reasoning over StructuralParts and Fasteners. We design a lightweight domain ontology that diferentiates the principal subclasses of mechanical fasteners – screws, nuts, bolts, washers, pins, snap-rings—alongside generic StructuralParts (any load-bearing or functional component that is not itself a fastening element and whose removal would break the kinematic chain of the assembly). We capture how each fastener constrains the assembly order. A set of SWRL rules encodes generic engineering axioms (e.g. “a nut typically is assembled after its mating screw”), enabling a reasoner to infer precedence relations automatically from an instantiated product model.
Together, these elements yield a pipeline that (i) operates directly on original CAD assemblies, (ii) extracts function-aware precedence constraints, and (iii) scales to structurally diverse products due to the employed semantic extraction and reasoning which are driven by reusable class-level knowledge rather than instance-specific scripts.
In this research, a domain ontology is developed to represent assembly-related knowledge extracted
from CAD models. Figure 1 summarises the implemented pipeline in which the ontology captures key
concepts such as components, geometric features, and their spatial relationships, which are essential
to determine the precedence matrix. This transformation from the low-level geometric
representation (extracted from STEP files) to a high-level ontological model is referred to as the semantic lift.
Semantic Web Rule Language (SWRL) rules enable reasoning to infer the assembly priority between
each two connected components, which in turn leads to generating a precedence matrix. The
emphasis is on practical reasoning and knowledge representation to derive assembly sequences from
CAD data. To formalize the semantic model of mechanical assemblies, a layered, top-down ontology
is adopted (Figure 2). The upper taxonomy – artifact, Part, Feature, Connection – captures what the
constituents are. Mereological (e.g., hasPart) and functional/kinematic relations (e.g.,
hasConcentricConnection, precedesOver) capture how they interact. Although the Connection and Feature classes
are included for conceptual completeness, we do not instantiate them in the current implementation.
Detecting contact types (concentric/coincident) requires numeric geometric computation (e.g., axis
alignment, interval overlap) that OWL/SWRL cannot perform; we therefore run this in the CAD
preprocessor and assert the results as direct part–part properties (hasConcentricConnectionWith,
hasCoincidentConnectionWith). The ontology remains essential as the semantic layer that
organizes these assertions, supports SWRL-based precedence rules over Fastener/StructuralPart
classes, and enables validation and querying at the assembly level, avoiding ontological verbosity while
capturing exactly the concepts needed for precedence sequencing (including fastener subclasses such
as screw, nut, washer, pin, snap-ring). As we will extend to additional connection types (e.g., threaded
engagements, welds, press-fits), we can reify detected links as Connection individuals to attach attributes
and check type-specific constraints, without changing the geometric pipeline. Hence, we deliberately
designed a lightweight, domain-specific ontology tailored to assembly precedence, rather than reusing
a broad upper ontology or existing standards. The primary reason is that general ontologies (e.g., BFO
or ISO 15926) are very comprehensive and domain-independent, which would introduce substantial
complexity without directly supporting our specific needs in assembly sequence reasoning. Similarly,
we didn’t use OntoSTEP ontology [
Our pipeline distinguishes two types of contact information extracted from the STEP model: 1. Concentric (cylindrical) connections. Two components form a concentric connection when they share a coaxial cylindrical interface whose radii, axial directions, and centre-line ofsets all lie within the specified geometric tolerances. Practically, this arises when a boss (external cylinder) on one part mates with a hole (internal cylinder) on the other, the cross-sectional profiles of both features being equivalent up to the tolerance band. All threaded joints (e.g., screw-nut engagements) are treated as a subclass of concentric connections, as they inherit the same coaxiality constraint and analogous mating geometry. We first parse the Boundary Representation (B-Rep) data and collect all cylindrical faces. A pair of components ⟨, ⟩ is marked concentric when they meet several conditions (explained in detail in section 2.1). 2. Coincident connections. A coincident connection is established when two StructuralPart instances present mating planar faces that are coplanar within the prescribed positional and angular tolerances, creating a flush interface. Because the plane itself ofers no intrinsic resistance to separation along its normal, the parts are ultimately retained by external fasteners – e.g., screw/bolt–nut sets or locating pins – inserted through the aligned clearance holes in the coincident faces. A coincident relation is not read directly from the CAD file; instead it is inferred from the fastening pattern. Two StructuralPart instances and ℓ are declared coincident if (i) each has a concentric connection with the same fastener (pin, screw, bolt, . . . ), and (ii) the axes of those concentric connections are colinear. (iii) For cylindrical faces classified as “hole”, the relative positioning of their bounding boxes must adhere to a specified tolerance. These rules capture typical face-to-face joints retained by pins or screws and avoid accidental matches.
The geometric-topological pre-processing is performed entirely in Python scripts by using pythonOCC
– a high-level wrapper around the Open Cascade CAD Technology (OCCT) kernel [
Algorithm 1: Interval-based concentric-connection detection
foreach unordered face pair (ℎ, ) with typeℎ = hole and type = boss do foreach part ∈ do end ← end
OCCT GetCylindricalFaces(); foreach face ∈ do
store ( , d , p , type ) *[r]type ∈ {hole, boss} if |ℎ − | < then if
∑︁ ∈{,,} 1︀( |ℎ −
| < )︀ ≥ 2 then Project vertices of ℎ and onto dℎ ; [ℎmin, ℎmax], [min, max] ←
axial intervals; min(︀ ℎmax, max − max(︀ ℎmin, min︀) ;
︀) ︀{( part(ℎ), part()︀)} ; Δ ← end if Δ ≥ then
← ∪ end end end return ;
The ontology distinguishes object properties, which connect individuals, from data-type properties that encode geometric or literal metadata. Domains, ranges and cardinalities are declared in OWL to enable logical validation and SWRL rule execution.
Data properties.
Table 1 summarises the core data-type properties that underpin our feature-level ontology. Geometric attributes apply to every Feature: the axis-aligned bounding box is delimited by its extremal vertices (minCornerX/Y/Z, maxCornerX/Y/Z); the frame is defined by the reference point originX/Y/Z and the unit axis vector directionX/Y/Z. For hole and boss features, a one-dimensional bounding interval, intervalMin/Max, measured along the feature’s principal axis. The scalar radius specifies the cross-sectional size. Assembly semantics are declared only for StructuralParts: an integer hasLayer encodes for each StructuralPart to belong to which build layer, and the Boolean isBasePart identifies the component that must be placed first. Unlike previous approaches that compute a single axis-aligned bounding box (AABB) for an entire solid, we generate feature-level AABBs exclusively for hole and boss primitives. Restricting the enclosure to these functional features prevents spurious spatial relations that arise when part-level envelopes of disjoint components overlap or merely touch in highly intricate assemblies. Consequently, by building one-to-one correspondence between genuine mating features, eliminates false positives without sacrificing computational eficiency.
Object properties. Table 2 lists the ontology’s core object properties that characterize how two components (either StructuralPart or Fastener) relate in an assembly. The precedesOver imposes an explicit assembly order, while isAdjacentWith flags axial proximity. Collectively, these properties provide a compact yet expressive vocabulary for inferring connection typology and precedence between any pair of components.
2.3.1. Layer-based Ontology Approach Our method initiates by selecting a single component from the StructuralPart class to serve as the BasePart, which is assigned to Layer0. Subsequently, all components from the StructuralPart class that are geometrically connected to the BasePart – either via cylindrical or coincident connections—are identified and assigned to Layer1. This process is applied recursively: for each subsequent layer (Layer2, Layer3, etc.), we identify components connected to any component in the previous layer, continuing until all StructuralPart components have been assigned to a specific layer. 2.3.2. Precedence Resolution between Fasteners and Structural Parts Table 3 encodes assembly knowledge in the form of SWRL rules to determine precedence relationships between two connected components – either both belonging to the Fastener class, or one from the Fastener class and the other from the StructuralPart class. When two parts are clamped using fasteners (e.g., screw and nut), the fasteners are typically assembled after the structural parts. Proposed SWRL
SWRL Rules Explanation Fastener(?p) ^ StructuralPart(?q) ^ Ensures that when a concentric connection exists between hasConcentricConnectionWith(?p, ?q) → a component of the Fastener class and a component of the precedesOver(?q, ?p) StructuralPart class, the StructuralPart is assigned precedence over the Fastener in the assembly sequence.
SnapRing(?p) ^ StructuralPart(?q) ^ When a snap ring prevents the axial movement of a Structural isAjacentWith(?p,?q) → precedesOver(?q, Part to which it is adjacent, the Structural Part must precede ?p) the snap ring in the assembly sequence to allow proper insertion and engagement.
Screw(?p) ^ Nut(?q) ^ When a screw and nut are both required to fasten two StruchasConcentricConnectionWith(?p, ?q) → tural Parts, the screw is assigned precedence over the nut, precedesOver(?p, ?q) as it must be installed first to accommodate the subsequent threading and tightening of the nut.
Washer(?p) ^ Nut(?q) ^ StructuralPart(?r) ^ When a screw, washer, and nut are all required to fasten two isAjacentWith(?p,?q) ^ isAjacentWith(?p,?r) ^ Structural Parts, and the washer has been positioned before differentFrom(?q, ?r) → precedesOver(?r, the nut during assembly, the washer is assigned precedence ?p),precedesOver(?p, ?q) over the nut, as it must be installed first to ensure proper load distribution and to accommodate the subsequent threading and tightening of the nut.
Washer(?p) ^ StructuralPart(?q1) ^ A washer placed between two StructualParts (?q1 and ?q2) StructuralPart(?q2) ^ isAdjacentWith(?p, ?q1) must follow whichever part has a lower layer value and pre^ isAdjacentWith(?p, ?q2) ^ differentFrom(?q1, cede the part with a higher layer. This ensures a correct ?q2) ^ hasLayer(?q1, ?L1) ^ hasLayer(?q2, ?L2) “stacking” order between washer and two structural parts. ^ swrlb:lessThan(?L1, ?L2) → precedesOver(?q1, (Note: Since SWRL rules do not support the ’OR’ operator, we ?w), precedesOver(?w, ?q2) need to rewrite the rule separately for each option.) StructuralPart(?p) ^ StructuralPart(?q) When a concentric (cylindrical) connection exists between ^ hasConcentricConnectionWith(?p,?q) ^ two StructuralPart instances—p and q, the part positioned on hasLayer(?p, ?L1) ^ hasLayer(?q, ?L2) ^ the lower layer is assembled first. Due to the absence of a swrlb:lessThan(?L1, ?L2) → precedesOver(?p, logical OR operator in SWRL, this condition is represented ?q) using two separate sub-rules ((L1) and (L2)), each capturing one possible ordering scenario.
StructuralPart(?p) ^ StructuralPart(?q) When a coincident connection—fastened by an instance of the ^ hasCoincidentConnectionWith(?p, ?q) ^ Fastener class—exists between two StructuralPart instances, p hasLayer(?p, ?L1) ^ hasLayer(?q, ?L2) ^ and q, the part located on the lower layer is assigned assembly swrlb:lessThan(?L1, ?L2) → precedesOver(?p, precedence.
?q) rules are relatively concise, however, their development requires careful attention to domain semantics. Fewer than 10 rules were suficient to cover common fasteners and structural parts in the current case studies. The method scales well with increasing part count, since reasoning operates at the component level and avoids low-level feature modeling in OWL. However, certain limitations remain: Our current framework assumes a flat assembly structure without nested sub-assemblies and without significant symmetric layouts.
Following the workflow of Section 2, the STEP file of each assembly is processed as follows: 1. Geometry & connection export (JSON): the parser emits a JSON scene graph that records unique part identifiers and canonical geometry, every detected mating feature, typed as cylindrical (hole–boss) or planar coincident, and auxiliary relations (e.g., adjacentTo for washers and snap-rings). 2. Semantic lift (OWL/Turtle): The JSON graph is automatically translated to OWL and loaded into Protégé, instantiating object properties such as hasConcentricConnectionWith, hasCoincidentConnectionWith, precedesOver, class assertions such as StructuralPart, Fastener::Screw, and the data properties such as hasLayer. 3. Rule-based inference (SWRL): a library of SWRL rules derives precedence predicates between every connected pair, thereby populating the precedence matrix. We ran the entire pipeline on two open CAD datasets from GrabCAD1 – a 20-part bench clamp and a 23-part air-compressor (see Figure 4, including their exploded views, connection graphs, and layer-based decomposition in Figure 5, where components are stratified into defined layers. Tables 4,5 convey the same precedence information in formal, machine-readable form via the binary precedence matrix, enabling direct algorithmic validation and quantitative comparison of assembly orders returned by the SPARQL query after OWL + SWRL reasoning. A “1” in row i, column j means “part i must be assembled before part j”, for instance, basePart dominates all components in both case studies. Such a precedence matrix compactly encodes the partial-order constraints among assembly tasks; any human or robotic planner can then derive one or more admissible sequences that satisfy those constraints.
This work has established a fully automated, ontology-driven pipeline that transforms native STEP geometry into a function-aware precedence matrix for assembly planning. We extracted automatically concentric and coincident connections, instantiated a lightweight OWL domain ontology, and enriched it with SWRL rules that encode generic engineering axioms for functional parts and fasteners and then derived the precedence matrix. Parts are hierarchically stratified into connection-based layers— starting with the BasePart in Layer 0—such that each subsequent layer contains only those components physically attached to parts in all preceding layers. Validation on a 20-component mechanical clamp and a 23-component air-compressor confirms that the inferred matrices reproduce expert-verified ordering constraints.
In any assembly-planning approach, the search space grows with the number of inter-part constraints. This work is no exception; the phenomenon is inherent to the task rather than to a particular algorithm. A notable advantage of our method, however, is that its layer-based ontological reasoning imposes no upper bound on the number of build layers extracted from the CAD model: precedence inference operates over an arbitrary layered hierarchy without degrading in correctness or completeness. The current implementation relies on manually annotated part names to identify fasteners, which limits full automation when names are missing, non-standard, or ambiguous. In future work we plan to incorporate feature-based recognition. Furthermore, the current two-layer detector handles only concentric and coincident relations. In future work we will extend the ontology and detection logic to additional constraint types that commonly appear in CAD assemblies – most importantly threaded engagements and gear-gear meshes, and planar contacts. We also plan to explore aligning our ontology with established standards (for parthood, connection, shape, and function) in our future work.
This work was supported by the European Union Next-Generation EU (PIANO NAZIONALE DI RIPRESA E RESILIENZA (PNRR) – MISSIONE 4 COMPONENTE 2, INVESTIMENTO 3.3 – Decreto del Ministero dell’Università e della Ricerca n.117 del 02/03/2023) within the Advanced-Systems Engineering Ph.D. Program of the Free University of Bolzano and Durst Group AG. We also acknowledge the ifnancial support through the ‘Abstractron’ project funded by the Autonome Provinz Bozen - Südtirol (Autonomous Province of Bolzano-Bozen) through the Research Südtirol/Alto Adige 2022 Call.
During the preparation of this work, the authors used GPT-4 in order to improve grammar and spelling. After using this service, the authors reviewed and edited the content as needed and take full responsibility for the publication’s content.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23