Constraint-Based Disassembly Sequencing Algorithms for Dismantling Applications—A Comparative Study

Abstract

With growing interest in automated dismantling operations for hazardous environments, automatically planning safe and efficient disassembly sequences is becoming increasingly important. When a large structure is segmented into parts, the removal order must ensure that each part can be extracted safely without destabilising the remaining structure. This paper presents a comparative study of four algorithms for solving the disassembly sequencing problem in two dimensions: First Feasible Random Search (FFRS), Greedy Search (GS), Height-Decreasing Search (HDS), and Stochastic Tree Search (STS). The present study focuses specifically on sequencing feasibility under geometric and physical constraints, namely connectivity, accessibility, and structural stability. The 2D formulation provides a simplified yet computationally efficient testbed for analysing algorithmic behaviour under varying cutting complexities, with the objective of minimising the total removal trajectory length. Results show that while STS consistently finds optimal or near-optimal solutions, its factorial runtime limits scalability. GS produces high-quality solutions efficiently but can become trapped in infeasible configurations, whereas HDS offers strong reliability and speed at the expense of solution quality. Based on these findings, a hybrid height-based backtracking algorithm is proposed as a promising future direction, combining the efficiency of greedy search with the robustness of stochastic exploration. The results provide insight into the relative strengths and limitations of different sequencing strategies and establish a foundation for future extension to more realistic dismantling scenarios, including 3D and radiologically constrained applications.

1. Introduction

Large-scale dismantling operations present significant engineering challenges due to the need to safely segment, remove, and process interconnected structural components under geometric and physical constraints. These challenges are particularly important in hazardous environments, where poor sequencing decisions may compromise safe access, structural integrity, or operational safety.

One particularly important application area, as well as the primary motivation for the present study, is nuclear decommissioning, where dismantling operations frequently involve large, interconnected structures within hazardous and highly constrained working environments.

Nuclear decommissioning is a complex and resource-intensive process that involves the decontamination, dismantling, and safe storage of structures and materials from nuclear power plants that have reached the end of their operational life. According to the International Atomic Energy Agency (IAEA), as of 2020 there were 686 reactors worldwide at different stages of their life cycle: 442 operational, 52 under construction, 172 permanently shut down, and only 20 fully decommissioned [1]. In the UK alone, decommissioning activities are expected to generate waste until 2136, producing a total volume of approximately 4.45 × 10⁶ m³ [2]. Of particular relevance to this work are large structural components such as reactor pressure vessels (RPVs), heat exchangers, and pipe networks, which together account for an estimated 436,200 m³ of this total [2]. These structures must typically be segmented by cutting before individual parts can be removed, handled, and packed for transportation and long-term disposal.

In this context, disassembly sequencing plays a critical role. The order in which parts of a structure are cut and removed directly affects safety, feasibility, and efficiency. A feasible sequence must ensure that each part can be extracted along a collision-free trajectory, without being blocked by surrounding geometry, and without violating constraints such as structural stability (i.e., whether the structure remains stable once a part is cut and removed). Poorly planned sequences risk dead-end situations, where remaining parts become inaccessible, or where the removal of parts may lead to structural collapse.

Traditionally, sequencing has been handled by human experts. However, as automation becomes increasingly important in dismantling operations, there is growing demand for computational methods capable of assisting with these decision-making processes. Autonomous algorithms offer the potential to generate safe and efficient disassembly plans more consistently and at greater speed than manual approaches, reducing reliance on human expertise while improving reproducibility of the planning process. More effective sequencing strategies may also support broader operational objectives, such as reducing dismantling time, improving accessibility, and streamlining downstream handling and disposal operations.

1.1. Literature Review

The problem of disassembly sequencing has been extensively studied, particularly in the context of recycling electronic and mechanical products, where the goal is to identify sequences that facilitate component reuse or material recovery. Applications include disassembly planning for household items such as desktop computers [3,4], coffee makers [5], electric drills [6], printers [7,8], and LCD TVs [9,10,11], as well as mechanical systems like car engines [12,13], gearboxes [14,15], and water pumps [16]. Comprehensive reviews of this body of work are available in [17,18].

While effective for small-scale products, these approaches are often not directly applicable to large-scale dismantling operations. In particular, many methods do not account for structural stability or detailed part-removal trajectories, which are critical when dismantling large, heavy structures robotically. In decommissioning contexts, unsafe sequencing could cause instability or collapse, posing risks to human operators and equipment.

To date, the only work the authors are aware of that explicitly considers disassembly sequencing in a decommissioning context is [19], which developed an algorithm for large structures inspired by tasks such as shipbreaking and aircraft dismantling. While this represents a step towards applying sequencing to large-scale hazardous dismantling, their framework allowed cut parts to fall from the structure and undergo further processing on the ground.

In contrast, the present study considers a different operational scenario. A complete cutting pattern is assumed to be known a priori (as this is typically determined by operational factors related to cutting and downstream packing considerations), and the focus is on determining a safe removal sequence for the cut parts. Parts are removed one at a time, with explicit computation of linear, collision-free extraction trajectories. This reflects a case where a robotic manipulator grasps a part immediately after cutting and then transfers it (in a controlled manner) either to a temporary storage location (for packing later) or directly to a waste container. Furthermore, this study also treats stability as a hard constraint, i.e., parts cannot be removed if doing so would destabilise the remaining structure. By contrast, ref. [19] did not enforce stability as a strict requirement, instead minimising the motion of falling parts but permitting the structure to collapse during disassembly.

Though not directly related to decommissioning, two recent works worth noting are [20,21]. In ref. [20], the authors propose an assembly by disassembly approach to optimise robotic assembly by first identifying efficient disassembly sequences and then reversing them. Their algorithm shares similarities with the present study in that it seeks to minimise trajectory lengths, enforce collision-free removal paths, and maintain stability of the partially disassembled structure. However, their stability check is based on a simplified gravity constraint: after each removal, they ensure no part can move downward under gravity. This functions similarly to the connectivity constraint employed here, which prevents unsupported or disconnected parts, but it does not capture broader structural behaviours such as tipping or collapse. By contrast, this study treats stability as a strict physical requirement, using static analysis to confirm that the structure remains stable at every step.

In ref. [21], the authors also adopt an assembly-by-disassembly framework to generate robotically executable assembly plans. As in ref. [20], they incorporate collision-free trajectories and gravity-based stability constraints, but they go further by explicitly modelling gravity through a physics simulator, enabling a more realistic assessment of stability than the static analysis used here. Their focus, however, is primarily on feasibility rather than optimality: the goal is to identify any valid disassembly plan quickly, rather than to minimise the cumulative trajectory length of all parts. In contrast, the present study explicitly optimises path length, aiming to generate more efficient removal sequences that reduce overall disassembly time.

1.2. Focus of Paper

In this paper, a novel methodology is presented for disassembling cut structures, where the objective is to minimise the total trajectory length of the cut parts while ensuring that the structure remains physically stable throughout the process. To enable a systematic comparison of candidate algorithms, the problem is formulated in two dimensions (with the presented methodology being extendable to 3D). While this simplification does not capture the full geometric complexity of real-world dismantling operations, it provides a computationally efficient and controlled test environment. This allows clear evaluation of algorithmic performance in terms of solution quality, constraint handling, and scalability, before extending insights to more realistic 3D cases.

Specifically, the present study focuses on the geometric and physical feasibility aspects of disassembly sequencing, namely collision-free accessibility and structural stability during part removal. While practical dismantling operations may also involve additional considerations such as contamination control, radiation exposure, waste categorisation, and downstream disposal logistics, these factors are outside the scope of the current work and are instead viewed as potential constraints and optimisation objectives for future extensions of the framework. Similarly, while the proposed framework is motivated by dismantling scenarios involving robotic or assisted part handling, the present study does not explicitly model robotic kinematics, manipulator dynamics, grasp planning, or non-linear motion planning. Instead, part accessibility is approximated using simplified linear extraction trajectories to enable controlled comparison of sequencing strategies. The intention of the present study is therefore not to provide a complete decommissioning optimisation methodology, but rather to evaluate and compare different sequencing strategies under controlled conditions before incorporating additional operational complexities.

To address this problem, three optimisation algorithms are proposed and systematically compared: a greedy search algorithm, a heuristic-driven algorithm, and a tree search–based algorithm. These are benchmarked against a random search baseline to provide a reference for evaluating performance. In addition, a fast approximation method for assessing static stability is introduced, adapted from the support polygon concept widely used in robotics. This approach enables rapid estimation of whether the remaining structure would remain upright after each removal step, without requiring computationally expensive force or deformation calculations.

The main contributions of this work are summarised as follows:

• Formulation of a 2D disassembly sequencing problem incorporating key constraints of collision-free part trajectories and structural stability.
• Development and implementation of three optimisation algorithms (greedy search, heuristic-driven, and tree search) within a unified evaluation framework, alongside benchmarking against a random search baseline.
• Comparative analysis of algorithm performances across different cutting complexities, highlighting strengths, limitations, and implications for extension to more realistic 3D dismantling scenarios.

The remainder of this paper is structured as follows. Section 2 presents the materials and methods, including the problem formulation, constraint enforcement strategies, and the optimisation algorithms evaluated. Section 3 reports and discusses the results, analysing algorithmic performance, computational scaling, and solution quality. Section 4 concludes the paper, summarising the key findings and outlining directions for future research.

2. Materials and Methods

This section describes the methodology and computational framework used in this study. Section 2.1 formally defines the disassembly sequencing problem and the objective function/constraints considered. Section 2.2 details the implementation of the physical and geometric feasibility constraints (connectivity, stability and accessibility). Section 2.3 outlines the four optimisation algorithms developed and compared for solving the problem.

All the algorithms developed in this study were implemented in MATLAB 2024b, making extensive use of the ‘polyshape’ library for geometric and shape-based operations. The experiments were run on a laptop computer with an Intel Core i7-1165G7 processor and 16GB of RAM.

2.1. Problem Description

The disassembly sequencing problem investigated in this study aims to determine the optimal order in which parts of a cut structure should be removed such that the total disassembly cost (sum of part trajectory lengths) is minimised, while satisfying a set of physical and geometric constraints (namely, connectivity, stability and accessibility).

The input test structure (depicted in Figure 1) is decomposed using a Binary Space Partitioning (BSP) approach, in which successive planar cuts are applied to partition the object into multiple parts. Each cutting pattern is represented as an ordered list of planes, where each entry defines the position and orientation of a single cut. Cuts are applied sequentially (starting with the first cut in the list), with each plane defined by its rotation angle and origin point. To ensure complete segmentation, the cutting planes are extended sufficiently to intersect the entire structure but are not permitted to intersect one another. For the purposes of this study, all the locations/orientations for the cutting planes were generated randomly.

Two different cutting scenarios are considered in this study:

•

Free-rotating cuts, where the plane orientations can take any integer value between 1–180 degrees.

•

Orthogonal cuts, where plane orientations are restricted to either 0 or 90 degrees.

These two cases provide different levels of part complexity, allowing assessment of how algorithmic performance varies with the degree of irregularity and part heterogeneity.

Given a randomly generated cutting pattern applied to the input structure, the goal of optimisation is to determine a removal sequence for all the parts that minimises the total disassembly cost, defined as the sum of the linear trajectory lengths for each removed part, i.e., $J={\sum }_{i=1}^n{L}_i$, where $L_i$ represents the trajectory length of part $i$, and $n$ is the total number of parts. Each trajectory is modelled as a straight line extending from the centroid of the part to the boundary of the structure’s bounding box (Figure 1). Trajectory length was chosen as the optimisation objective since, within the context of robotic or assisted dismantling operations, shorter removal trajectories are generally associated with reduced motion effort and lower overall disassembly time.

The optimisation problem is also subject to three key constraints:

• Connectivity constraint—The removal of a part must not result in disconnected or unsupported parts, as such parts would fall due to gravity in practice.
• Stability constraint—the partially disassembled structure must remain stable after the removal of each cut part.
• Accessibility constraint—For each removed part, a linear, collision-free trajectory must exist to move the part outside the structure’s bounding box without intersecting other parts.

As stated in Section 1.2, the problem is formulated in 2D to enable a controlled and computationally efficient comparison of sequencing algorithms (with the presented methodology being extendable to 3D contexts). However, it is also worth acknowledging that additional modelling simplifications were adopted in this study for clarity and consistency. For example, BSP cutting was chosen as a general-purpose segmentation strategy as planar cuts avoid interlocking geometries (which could make physical separation of parts impossible) and provide a simple mechanism for generating both free-rotating and orthogonal cutting patterns (enabling a controlled assessment of how part irregularity influences sequencing performance).

Additionally, part removal trajectories were restricted to straight-line paths to simplify the accessibility evaluation and avoid introducing non-linear motion planning complexity, which is beyond the scope of this study.

Finally, randomly generated cutting patterns were used to produce a diverse range of structural configurations for testing. Whilst industrial cutting patterns are typically defined based on operational and safety considerations, the objective here is not to optimise cutting itself, but to determine effective removal sequences given a predefined segmentation. Only cutting patterns for which at least one algorithm identified a feasible sequence were retained, ensuring fair comparison across solvable cases.

2.2. Constraint Enforcement

Each time a cut part is to be removed, the algorithm must check to see if it can feasibly be removed by evaluating the three aforementioned constraints. If none of the 3 constraints are violated, the part can be successfully removed. The three constraints used to assess whether a part can be removed are implemented as follows:

2.2.1. Connectivity

The connectivity constraint ensures that removal of a part does not result in the formation of floating or unsupported sub-structures (e.g., Figure 2a). After a candidate part is removed, the remaining structure is represented as an undirected connectivity graph, where each node corresponds to a part centroid and edges represent physical contact between adjacent parts (Figure 2b). When a part is removed, the graph is searched using a depth-first search procedure to verify that the remaining nodes still form a single connected component.

A virtual ‘base’ is also added to the bottom of the structure (represented by the lowest node outside the base of the structure in Figure 2b) to ensure that all remaining parts remain supported throughout disassembly. This prevents scenarios where the remaining structure, though connected, becomes detached from the ground and effectively ‘floats’ above it.

In implementation, contact information between parts (and between parts and the virtual base) is stored in an adjacency matrix that is dynamically updated after each removal. This provides an efficient means of checking for both structural connectivity and continued grounding support.

2.2.2. Stability

The stability constraint ensures that the remaining structure remains statically stable after the removal of any part. In this study, stability is evaluated using a geometric approximation based on the support polygon concept commonly employed in robotics for legged locomotion stability analysis. For a legged robot (such as the one depicted in Figure 3), it is considered statically stable on a horizontal plane if, at any given moment, the vertical projection of its Centre of Mass (COM) lies within its support polygon (the convex hull formed around the contact points with the ground) [22].

The stability test is implemented using a vertical slicing procedure which assesses stability throughout the remaining structure. After a candidate part is removed, the remaining structure is vertically sliced using evenly spaced horizontal lines (Figure 4a), and for each slice, the following steps are performed:

• Calculate the support polygon: Determine the intersection points where the horizontal slice line meets the outer boundary of the structure (red circles in Figure 4b). The line segment between these two points represents the support polygon for that slice.
• Calculate the COM: Compute the centroid for the portion of the structure that lies above the slice line.
• Project the COM: Project the centroid vertically down onto the slice to obtain the projected COM (red ‘x’ in Figure 4b).
• Evaluate stability: If the projected COM lies outside the support polygon for any slice, the structure is deemed unstable and the part removal is rejected. If all slices pass this check, the structure is considered stable under this static criterion.

Figure 5 gives a visual illustration of this concept. In this figure, the projected COM points for each slice have been joined together to form the continuous red line running through the structure. From the left example (Figure 5a), the red ‘stability line’ remains between the support polygon points (red circles) at all times, meaning the structure is stable. In contrast, with the two examples on the right (Figure 5b), due to the removal of parts from the structures, the remaining structures now have large unsupported overhangs. These overhangs cause the support line to leave the support polygon points at several parts of the structure, meaning both are considered unstable.

The reason for evaluating stability across multiple horizontal slices, rather than only at the base of the structure, is to capture potential internal instabilities that may develop higher up in the geometry. A single base-level support polygon check would only ensure that the overall structure does not topple as a rigid body but would fail to detect overhanging regions or narrow necks that could cause localised imbalance (potentially leading to material deformation) once parts are removed. By analysing successive slices and tracking the projection of the centre of mass through the height of the structure, the algorithm can approximate the overall stability profile more accurately.

It is also worth acknowledging that whilst this slice-based approach does not accurately capture dynamic effects, force distribution, or material deformation, it still provides a practical and efficient means of estimating static stability without requiring computationally expensive physics-based simulations. This trade-off between accuracy and computational efficiency makes it particularly well suited for large-scale disassembly simulations where numerous stability checks must be performed.

2.2.3. Accessibility

The accessibility constraint determines whether a selected cut part can be removed from the structure along a linear, collision-free trajectory. Each potential trajectory is represented as an angle, θ, around the part’s centroid, measured with respect to the global vertical axis (Figure 6a). The goal is to identify at least one feasible removal direction through which the part can be moved clear of the remaining structure without intersecting any other geometry.

To identify feasible trajectories, the 360° circle around the part’s centroid is discretised into uniformly spaced angular increments (with the increment size set by the user). For each sampled direction, two parallel lines are projected from the part’s widest points orthogonal to the direction of travel, extending toward the boundary of the structure’s bounding box. These lines define a virtual ‘travel tunnel’ representing the space the part would occupy if it were translated in a straight line along that trajectory (Figure 6b). An intersection check is then performed on these tunnel lines and the remaining structure.

If no intersections occur, the trajectory is considered collision-free, and the corresponding travel distance (from the part’s centroid to the bounding box) is recorded as its trajectory length. The algorithm then selects the feasible trajectory with the shortest travel distance, representing the most efficient removal path. If no feasible trajectory is found, the function returns −1, indicating that the part cannot be removed without violating collision constraints.

A simplified tunnel-based approach is adopted here rather than a full geometric translation method to reduce computational expense. In a direct translation scheme, the part would need to be incrementally moved and re-tested for collision at each step, greatly increasing the number of intersection checks. By contrast, the tunnel method requires only a single intersection test per sampled angle, significantly improving computational efficiency.

As a final point to note, a potential failure case can arise if a detached part lies entirely between the tunnel lines, allowing it to be missed by the intersection test. However, such a configuration is prevented by the connectivity constraint, which ensures that all remaining parts are connected before the accessibility check is performed. Hence, running the connectivity verification prior to trajectory evaluation guarantees the validity of the tunnel approach.

2.3. Optimisation Algorithms

Four optimisation algorithms are implemented and compared to identify effective strategies for generating feasible disassembly sequences. Each algorithm searches for a sequence that removes all cut parts while satisfying the connectivity, stability, and accessibility constraints described in Section 2.2. The four algorithms are as follows:

2.3.1. First Feasible Random Search (FFRS)

The FFRS algorithm is the simplest of the four algorithms. In each iteration, it will randomly generate a full disassembly sequence (a random permutation of the cut parts) before evaluating it, only stopping once a feasible sequence has been found, or the user-set cutoff time is reached. Due to its simplicity and lack of heuristic guidance, this approach serves as a baseline against which the performance of the other algorithms can be compared.

2.3.2. Height Decreasing Search (HDS)

HDS is a heuristic-driven, greedy search process which works by always selecting the highest cut part in the structure (with ties broken randomly) which can feasibly be removed at each step (with the height of each part defined by the y-coordinate of its highest point). This process ensures that the structure is disassembled in a top-down fashion. The idea behind this is that it aims to mimic real-world decommissioning practices, such as the dismantling of a reactor pressure vessel where the structure is typically supported at the base and sides, with components being cut and removed sequentially from the top to help maintain stability and ease of access [23,24].

2.3.3. Greedy Search (GS)

GS is another greedy search process which works by always selecting the (feasible) part with the shortest trajectory length at each step. Given that the goal is to minimise the sum of the trajectory lengths for all the cut parts, this algorithm aims to directly optimise this objective, but in a greedy fashion. By locally minimising the trajectory length at each step, the algorithm seeks to build a cost-optimised disassembly sequence quickly (by prioritising short-term gains in the total cost), but with no guarantees of global optimality.

2.3.4. Stochastic Tree Search (STS)

The final algorithm is a stochastic optimisation algorithm inspired by the algorithm presented in [25], originally developed for solving the knapsack problem. The STS algorithm aims to incrementally build solutions from scratch, with the ability to backtrack in the search procedure if it encounters an infeasible dead end (a point where no more parts can be removed without violating constraints), or it has found a complete solution (in which case it backtracks to try and find a better one).

The algorithm starts with an ordered list of parts which are sorted from highest part to lowest (based on each part’s highest point). The search process is structured as a branching decision tree where each node represents a partial or complete solution, and contains the following information:

•

X: a list of parts already removed from the structure.

•

J: a list of remaining parts in the structure.

•

Cost: the accumulated cost of the current partial solution (i.e., the sum of the trajectory lengths for all parts in X).

The branches in the tree represent a binary yes/no decision on whether to remove the first part in J. At each node, the algorithm considers the first part in J and evaluates whether it can be removed:

•

If the part can feasibly be removed: the algorithm follows the ‘yes’ branch and removes the part (moving it from J to X and updating the accumulated cost). Simultaneously, it stores the alternative ‘no’ branch (in which the part is not removed and instead pushed to the back of J) into a temporary storage set for potential backtracking.

•

If the part cannot feasibly be removed: the algorithm has no choice but to take the ‘no’ branch, pushing the part to the back of J to be revisited later. In this case, the ‘no’ branch is not stored, since there is no alternative path which can be taken.

The tree is explored in a depth-first manner, meaning the algorithm will always attempt to build a complete solution (by selecting the ‘yes’ branch whenever possible) before backtracking. Stochastic backtracking occurs either when the algorithm encounters an infeasible dead end (where no more parts in J can be removed without violating constraints), or if the algorithm has found a complete feasible solution (in which case the goal of backtracking is to explore alternate paths to see if a better solution exists). When the backtracking procedure is triggered, a random node from the temporary storage set is selected and the algorithm resumes its search by taking the path that was not previously selected.

To reduce the size of the search space and encourage exploration of more promising paths, a ‘pruning’ procedure is also implemented. Each time a cut part is selected for removal, the algorithm will compare the current accumulated cost of the partial solution with the total cost of the best-found solution so far. If the current cost exceeds the best cost, the algorithm does not continue down its current path, since doing so would only increase the cost more. In such a case, the stochastic backtracking procedure is triggered to push the algorithm down a different path (effectively ‘pruning’ that branch of the tree).

Finally, as with the FFRS algorithm, a user-defined time limit must also be specified for the STS algorithm since without it, the search would effectively degenerate into stochastic enumeration of all possible combinations.

3. Results & Discussion

This section presents the results of the disassembly sequencing experiments for both the free-rotating and orthogonal cutting scenarios (defined in Section 2.1). For each cutting scenario, tests were performed across three levels of structural complexity—low (3–5 cuts), medium (10–15 cuts), and high (40–45 cuts)—to evaluate algorithmic robustness under increasing geometric and combinatorial difficulty.

A total of 24 distinct random cutting patterns were generated for each scenario. Specifically, for the free-rotating cuts, eight low-complexity, seven medium-complexity, and nine high-complexity patterns were produced; for the orthogonal cuts, nine low-, seven medium-, and eight high-complexity patterns were generated. Each of the four algorithms was executed three times per cutting pattern, and results were averaged across the three runs to mitigate stochastic variation.

The cut-off time for the FFRS and STS algorithms was set to 3 h, and the angle increment for the trajectory sampling was set to 10 degrees.

3.1. Algorithm Performance and Feasibility Trends

Figure 7 and Figure 8 present the distribution of algorithm outcomes across increasing problem complexities for both the orthogonal and free-rotating cutting scenarios. For each cutting pattern, the best result obtained among all algorithms is considered the optimal solution. Solutions with higher costs are classified as suboptimal, and cases where an algorithm failed to produce a feasible sequence are recorded as failures. The figures therefore provide an overview of algorithm robustness by showing the proportion of optimal, suboptimal, and failed solutions across all test instances within each complexity class.

When examining Figure 7 and Figure 8 above, a clear trend is observed as problem complexity increases. For the FFRS algorithm, performance deteriorates rapidly, with medium-complexity problems already showing difficulties in finding feasible solutions and high-complexity cases failing completely. This behaviour is expected, as FFRS samples removal orders at random under three strict constraints (connectivity, stability, and accessibility), making the probability of randomly producing feasible solutions extremely small as structural complexity grows.

For the GS algorithm, performance differences between cutting scenarios are apparent. Across all complexity levels, GS performs better for orthogonal cuts than for free-rotating cuts. The latter tend to produce parts with greater variation in shape and size, increasing geometric irregularity and making it more difficult to maintain feasible removal sequences. In such cases, a purely cost-driven (trajectory-length-minimising) heuristic is more likely to select a part whose removal compromises structural stability.

For example, consider the structure shown in Figure 9, corresponding to the low-complexity free-rotation cutting case where the GS algorithm failed to find a feasible sequence. In this case, if the parts are removed greedily according to their trajectory cost, the resulting disassembly order is {10, 7, 6, 8, 5, 2, 9, 4, 1, 3}. The issue arises near the end of this sequence, when only two parts remain—part 1 and part 3 (Figure 9b). With both parts present, the structure remains stable, as indicated by the red stability line. However, once part 1 (the large blue part) is removed, the remaining part 3 becomes unstable (Figure 9c), since its projected centre of mass lies marginally outside the base support polygon. This example illustrates how a purely cost-driven selection strategy can result in the premature removal of a structurally critical part, leading to an infeasible dead end even when the algorithm continues to select locally optimal trajectories.

Aside from occasional failures caused by infeasible dead-end configurations, the GS algorithm maintained a high proportion of optimal or near-optimal solutions as problem complexity increased. This behaviour can be attributed to its direct optimisation of the cost objective; by always selecting the part with the shortest trajectory, GS can rapidly construct low-cost solutions without extensive exploration of the search space. In contrast, the STS algorithm, while also cost-driven, relies on a broader tree-search strategy that evaluates many alternative part removal combinations. As the number of possible disassembly sequences grows factorially with the number of cut parts, this exploratory approach can become computationally inefficient at higher complexities. Consequently, GS often finds near-optimal solutions efficiently, albeit without guaranteeing global optimality and with some risk of infeasible configurations.

The HDS algorithm consistently achieves a high rate of feasible solutions across all complexity levels and cutting scenarios, failing in only one orthogonal-cut instance. Its success can be attributed to its top-down removal strategy, which tends to preserve stability and avoid constraint violations. However, since it follows a greedy selection process that does not explicitly optimise trajectory length (instead selecting the uppermost feasible part at each step), it often produces suboptimal solutions.

The STS algorithm achieved the most reliable overall performance, successfully finding feasible solutions for every test case and consistently identifying optimal or near-optimal solutions in low- and medium-complexity problems. For high-complexity cases, performance begins to decline, primarily due to the factorial growth of the search space, leading to occasional deviations from the optimum within the set time limit. Nonetheless, STS’s ability to integrate both exploration and exploitation allows it to balance feasibility and cost effectiveness more effectively than the other methods.

3.2. Run-Time Analysis and Computational Scaling

Figure 10 shows the runtime of each algorithm plotted against the number of possible disassembly sequence combinations, calculated as $n!$, where $n$ is the number of cut parts. The results are shown for the low-complexity free-rotating cutting case, with the $y$-axis logarithmically scaled. Only runs that produced feasible solutions are included; for example, the single failed GS run was excluded.

A clear distinction in computational scaling behaviour is observed across the algorithms. As shown in Figure 10, the runtime for the STS algorithm increases exponentially with the number of sequence combinations, reflecting its factorial search complexity, whereas the other three algorithms exhibit approximately linear trends. For the STS and FFRS algorithms, only the low-complexity cases are plotted, since both consistently reached the three-hour cutoff in the medium- and high-complexity tests. The final STS data point, marked with a green “×”, indicates a run that also reached the time limit before evaluating all possible combinations. These observations clearly demonstrate that although the STS algorithm is highly effective in finding feasible (and often optimal) solutions, its computational cost scales poorly with problem complexity, limiting its practicality for larger instances.

The FFRS algorithm also shows relatively high average runtimes (compared to HDS and GS), despite its linear trend. This behaviour is expected given its random sampling process, which lacks any form of heuristic guidance. By contrast, the GS and HDS algorithms demonstrate significantly lower computation times, even for higher-complexity instances. As shown in Figure 11, which plots runtimes for the medium- and high-complexity free-rotating cut cases (with a linear $y$-axis), both algorithms complete all runs in under 90 s (over two orders of magnitude faster than the three-hour runtime required by the STS and FFRS algorithms for the same complexity cases).

Although both GS and HDS exhibit linear runtime scaling, the GS algorithm shows a steeper gradient. This arises because, at each iteration, GS evaluates every remaining part in the structure against all three constraints before selecting the part with the shortest trajectory. Consequently, its computational cost increases linearly with the number of remaining parts. In contrast, the HDS algorithm evaluates parts in descending order of height and stops at the first feasible candidate, dramatically reducing the number of constraint checks per iteration. This strategy results in a noticeably flatter runtime curve, making HDS the most computationally efficient among the four algorithms.

As a final point to note, only the results for the free-rotating cutting scenario are reported here, as the orthogonal-cutting tests exhibited similar computational trends and are therefore omitted for brevity.

3.3. Solution Quality Assessment

Having examined the feasibility and runtime behaviour of the four algorithms, this section evaluates the quality of the solutions produced in terms of their effectiveness in minimising total disassembly cost. To enable a consistent comparison across test cases, a performance metric termed ‘cost strength’ was defined to quantify the relative quality of each algorithm’s solution for a given cutting pattern.

The cost strength metric measures how close an algorithm’s returned cost is to the best (minimum) cost obtained among all algorithms for that same cutting pattern. It is calculated as:

$$CostStrength={\displaystyle \frac{MinReturnedCost}{AlgorithmReturnedCost}}$$

(1)

This yields a fractional value between 0 and 1, where

•

1 indicates the algorithm achieved the optimal (lowest) cost.

•

<1 indicates deviation from the optimum, with smaller values representing poorer performance.

•

0 denotes failure to find a feasible solution.

To illustrate, consider a simple example where four algorithms produce the following disassembly costs for a given cutting pattern:

$$FFRS=92,\hspace{1em}\hspace{1em}HDS=94,\hspace{1em}\hspace{1em}GS=failure,\hspace{1em}\hspace{1em}STS=88\left(thebest\right).$$

(2)

The cost strengths are therefore:

$$FFRS={\displaystyle \frac{88}{92}}=0.957,\hspace{1em}\hspace{1em}HDS={\displaystyle \frac{88}{94}}=0.936,\hspace{1em}\hspace{1em}GS=0\left(failure\right),\hspace{1em}\hspace{1em}STS={\displaystyle \frac{88}{88}}=1.000$$

(3)

In this example, the STS algorithm achieved the lowest cost (cost strength = 1), while GS failed to produce a feasible sequence (assigned a value of 0). The FFRS and HDS algorithms produced suboptimal solutions with fractional values between 0 and 1. This convention avoids undefined division in failure cases while maintaining a consistent scale for comparing solution quality across algorithms.

For each cutting pattern, cost strength values were computed for all four algorithms, then averaged across all patterns at each complexity level (low, medium, and high) and across both cutting scenarios.

Table 1. Average cost strength across different problem complexities and cutting scenarios.

	Free Rotating Cuts				Orthogonal Cuts
Complexity level	FFRS	GS	HDS	STS	FFRS	GS	HDS	STS
Low	0.985	0.875	0.963	1.000	0.960	1.000	0.941	1.000
Medium	0.140	0.710	0.898	1.000	0.137	1.000	0.662	1.000
High	0.000	0.888	0.869	0.997	0.000	0.875	0.754	0.987
Avg.	0.375	0.824	0.910	0.999	0.366	0.958	0.786	0.996

summarises the results.

Across both cutting scenarios, the STS algorithm consistently achieved the highest average cost strength, with overall averages close to 1. The only deviations occurred in the high-complexity cases, where STS occasionally produced near-optimal (rather than exact) results, reflecting its limited runtime rather than failure to locate feasible solutions. In contrast, the FFRS algorithm performed the worst overall, with cost strength decreasing sharply as problem complexity increased, highlighting the inefficiency of a purely random search under strict constraints.

The GS algorithm demonstrated higher cost strength for orthogonal cuts than for free-rotating cuts, consistent with earlier observations that free-rotating cutting tends to produce more irregular parts and therefore increases the likelihood of stability violations. Failures in the free-rotating scenario reduced the GS average considerably, whereas for orthogonal cuts (where geometric regularity improved stability) GS succeeded more consistently and achieved near-optimal costs.

Conversely, the HDS algorithm showed slightly higher average cost strength for the free-rotating scenario than for the orthogonal case. This outcome reflects the top-down removal heuristic, which inherently promotes stable disassembly even for irregular geometries. While HDS did not achieve the lowest costs overall, it proved the most reliable at maintaining feasibility across all test conditions. In contrast, GS tended to produce higher-quality (lower-cost) solutions when successful, but with reduced robustness.

Overall, these results confirm that while HDS offers strong reliability, GS provides higher-quality solutions when feasible, and STS delivers both optimality and consistency at the expense of runtime.

3.4. Implications for Nuclear Decommissioning

Although the present study considers a simplified 2D formulation, the long-term motivation of this work is the development of automated and robotic dismantling methodologies for nuclear decommissioning applications. In a practical implementation, the proposed sequencing framework would form part of a broader dismantling planning pipeline. For example, in the case of reactor pressure vessel segmentation, the framework could be used after a cutting plan has been defined to assess whether the resulting segments can be removed in a feasible sequence while satisfying geometric, physical, remote-handling, and radiological constraints. The input to such a framework would likely be a pre-processed and labelled digital model of the structure, derived from CAD geometry and supplemented with engineering information such as material type, density or mass estimates, and radiological characterisation data. These additional labels would need to be defined in advance, either manually by engineers or through separate characterisation and modelling workflows, rather than being inferred by the sequencing algorithm itself. A cutting plan would then be defined, either by a human planner or an autonomous cutting algorithm, based on operational constraints such as component size, mass or radiation limits, tooling capabilities, accessibility requirements, and downstream waste packaging considerations. Once segmented, the sequencing algorithm would evaluate candidate removal orders to determine whether the resulting parts could be extracted safely without constraint violation. The resulting sequence could then be used to support either human-supervised or fully autonomous dismantling operations.

While the present study focuses specifically on geometric accessibility and structural stability, future extensions of the framework would need to incorporate both nuclear-specific operational constraints and robotic execution constraints. From a nuclear-decommissioning perspective, ambient dose fields surrounding a partially dismantled structure could be estimated using point-kernel radiation transport methods accounting for source activity distributions and self-shielding effects from surrounding material [26,27]. From a robotics perspective, the framework would also need to model robot reachability, collision-free manipulator motion, non-linear trajectory planning, and grasp/tool access for individual cut parts. In such a workflow, sequencing decisions could be coupled with robot or tool positioning strategies to ensure that each part can be reached, cut, grasped, and removed while also minimising cumulative radiation exposure during dismantling operations. This would be conceptually similar to the cutter-positioning strategy considered in [19], but adapted from minimising risk due to falling parts toward minimising radiological exposure and improving robotic execution feasibility. Consequently, the optimisation problem would no longer depend solely on geometric feasibility, but also on how individual cutting and removal actions affect radiation hot spots, shielding/self-shielding effects, robot accessibility, and operator or robotic system exposure.

Despite this potential, several limitations currently prevent direct deployment in industrial decommissioning operations. The present implementation is restricted to two-dimensional test cases and does not yet include full robotic execution planning, material deformation modelling, or higher-fidelity physics-based stability assessment. It also does not currently account for radiological characterisation, exposure management, or waste-classification requirements necessary for deployment in nuclear decommissioning applications. Furthermore, since the framework assumes a predefined cutting pattern, infeasible segmentations may still arise. For example, cutting patterns containing strongly interlocking geometries or inaccessible internal regions may produce situations where no feasible disassembly sequence exists without violating accessibility or stability constraints. Even when interlocking does not occur directly, dead-end configurations may still emerge in which previously valid removal paths become blocked as dismantling progresses.

In the longer term, these limitations suggest the need for tighter integration between cutting and sequencing optimisation methodologies. Rather than treating cutting and sequencing as fully independent stages, future autonomous dismantling systems may instead employ iterative feedback between the two processes. In such a framework, the sequencing algorithm could identify infeasible or high-risk dismantling configurations and communicate this information to an adaptive cutting optimisation system capable of modifying the segmentation strategy until all required accessibility, stability, and operational constraints are satisfied. Consequently, the present study should be viewed not as a complete decommissioning solution, but rather as a foundational step towards more comprehensive autonomous dismantling planning frameworks capable of integrating geometric, physical, robotic, and radiological considerations.

4. Conclusions & Future Work

This study presented a comparative evaluation of four algorithms—First Feasible Random Search (FFRS), Greedy Search (GS), Height-Decreasing Search (HDS), and Stochastic Tree Search (STS)—for solving the 2D disassembly sequencing problem subject to connectivity, stability and collision-free trajectory constraints. The key findings can be summarised as follows:

•

FFRS performed well on low-complexity problems, producing feasible solutions quickly for both orthogonal and free-rotating cut cases. However, its purely random sampling strategy causes performance to degrade rapidly as problem complexity increases, leading to poor scalability.

•

STS demonstrated the best overall performance, consistently producing feasible and near-optimal solutions across all test cases. Its primary drawback is computational cost; runtime scales factorially with problem size, reaching the imposed three-hour cutoff for medium- and high-complexity cases. While robust and accurate, this limits its practical applicability to small- or medium-scale problems.

•

HDS achieved very high success rates, with only one failure case across all tests, and exhibited the lowest computation times (typically under seven seconds even for high-complexity problems). This reliability stems from its top-down disassembly strategy, which naturally preserves stability. However, since it does not explicitly optimise trajectory cost, it tends to produce suboptimal solutions.

•

GS produced high-quality (often optimal) solutions and maintained low computation times (below 90 s for all cases). Its cost-driven selection strategy is effective but can lead to infeasible sequences when geometric irregularities increase, particularly for free-rotating cut cases. The absence of backtracking makes it vulnerable to local infeasible optima.

Overall, the results highlight a clear trade-off between solution quality, feasibility robustness, and computational efficiency. While the STS algorithm provides the most accurate and reliable results, its scalability is limited by factorial computational growth. Conversely, HDS and GS offer practical alternatives for larger or time-constrained applications, balancing runtime and performance with moderate reductions in optimality.

Although this study was conducted in 2D, it is worth noting that the underlying combinatorial structure of the disassembly sequencing problem remains the same in 3D. The number of possible removal sequences still grows factorially with the number of cut parts, meaning that the relative scalability behaviour observed here (i.e., the factorial growth of the STS algorithm and the linear trends of the greedy heuristics) is expected to persist in 3D. The primary difference would lie in the increased computational cost of constraint evaluation (particularly the stability assessment and trajectory sampling) due to the introduction of additional degrees of freedom.

Consequently, while absolute runtimes would increase, the comparative trends between algorithms are likely to remain similar, with exploration-based methods offering high solution quality at increased computational expense and heuristic-driven approaches providing more scalable alternatives.

Future Work

Building on these findings, future work will focus on developing a novel hybrid optimisation algorithm that combines the efficiency of Greedy Search, the stability-awareness of Height-Decreasing Search, and the exploratory power of Stochastic Tree Search (STS). The proposed approach will retain the deterministic, cost-driven nature of GS but with a height-based backtracking mechanism designed to prevent infeasible dead ends. Unlike the purely stochastic backtracking used in STS, this method will leverage structural information (specifically, the height of removed components) to guide backtracking decisions. By revisiting earlier steps where lower cut parts were removed too early, the idea is to allow the algorithm to efficiently recover from instability-related failures while avoiding the full computational burden of stochastic enumeration.

Further work is also needed to validate and refine the stability model used in this study. While the slice-based static approach offers computational efficiency, its accuracy should be benchmarked against physics-based methods such as finite element or rigid-body simulations. If more realistic approaches are found to be computationally prohibitive (e.g., for problems with many cut parts) or if the static model is found to be too simplistic, future work may also focus on developing a hybrid approach (where the existing model acts as a fast estimator, with more realistic simulations used for borderline cases where stability is more uncertain).

Finally, extending this framework to more realistic 3D dismantling scenarios presents several challenges. From a robotics perspective, these include incorporating realistic robot kinematics and grasp planning, allowing for non-linear part trajectories, and integrating cutting and manipulation feasibility checks. Given the computational cost of high-fidelity robotic simulations, future research should explore fast approximation methods or two-stage evaluation frameworks, where simplified models guide the optimisation process and detailed checks are used to validate final candidate sequences.

For nuclear decommissioning applications specifically, future work should also incorporate radiological and waste-management constraints. This may include integrating radiological characterisation data, shielding/self-shielding effects, and waste-classification requirements into the sequencing objective function or constraint set. In the longer term, disassembly sequencing should also be coupled more closely with cutting optimisation, allowing infeasible or high-risk removal sequences to inform modifications to the cutting pattern. Such integration would support the development of more comprehensive autonomous dismantling planning frameworks capable of accounting for geometric, physical, robotic, and radiological constraints.