Optimal design of line replaceable units

A line replaceable unit (LRU) is a collection of connected parts in a system that is replaced when any part of the LRU fails. Companies use LRUs as a mechanism to reduce downtime of systems following a failure. The design of LRUs determines how fast a replacement is performed, so a smart design reduces replacement and downtime cost. A firm must purchase/repair a LRU upon failure, and large LRUs are more expensive to purchase/repair. Hence, a firm seeks to design LRUs such that the average costs per time unit are minimized. We formalize this problem in a new model that captures how parts in a system are connected, and how they are disassembled from the system. Our model optimizes the design of LRUs such that the replacement (and downtime) costs and LRU purchase/repair costs are minimized. We present a set partitioning formulation for which we prove a rare result: the optimal solution is integer, despite a nonintegral feasible polyhedron. Second, we formulate our problem as a binary linear program (BLP). The article concludes by numerically comparing the computation times of both formulations and illustrates the effects of various parameters on the model's outcome.


Introduction
System failures are major frustrations for their users.The consequences of failures can vary from discomfort, to disutility, to direct cost penalties such as downtime cost.In particular, industries that rely on systems to render a service or to manufacture a product experience high downtime cost.
For example, the downtime cost of a computer system of a brokerage company is roughly between $100,000-$1,000,000 per hour ( CNET News, 2001) and the downtime cost in the semiconductor industry is in the order of magnitude of $100,000 per hour (Parent, 2000).Together, the cost of downtime and maintenance can constitute up to 70-80% of a system's total life cycle costs ( Öner et al., 2007).As a consequence, it is crucial for a company's profitability to minimize the cost of downtime and maintenance.Significant cost reductions can be realized during the design phase of a system with relatively little effort.Asiedu and Gu (1998) show that 70-85% of the total life cycle costs are determined during the design phase, even though costs accrued in this phase only accounts for 10-20% of the life cycle costs (Norman, 1990;Saranga and Kumar, 2006;Öner et al., 2007).Hence, practice and research explore various system design concepts that enable a reduction of the after-sales costs including downtime and maintenance costs.Such concepts include common components (Thonemann and Brandeau, 2000;Briant and Naddef, 2004;Driessen et al., 2017), reliability and redundancy optimization ( Öner et al., 2013;Xie et al., 2014), and a smart design of Line Replaceable Units (Parada Puig and Basten, 2015).
A Line Replaceable Unit (LRU) is a collection of connected system parts that can be easily replaced when one of the parts in the LRU fails.An example of such a LRU is the wheel of a car that can be quickly replaced by a spare wheel incase of a tire puncture.The design of LRUs has a particularly large effect on downtime and maintenance, because they directly determine long a maintenance intervention lasts (Dhillon, 1999;Muckstadt, 2004;Birolini, 2007;Kumar et al., 2012).It is crucial for companies to design the LRUs in a smart way that minimizes the maintenance and downtime costs.Discussions with our project partners, ASML (a manufacturer in the semiconductor industry) and Dutch Railways (a maintenance, repair and overhaul company in the railway industry), indicate that this problem is highly relevant for their industries.Similarly, two case studies (Parada Puig and Basten, 2015;van Geel, 2018) at Thales (a manufacturer in the defense industry) and a case study (van Deursen, 2020) at Canon (a manufacturer of industrial printing equipment) report the same relevance, and other examples where LRUs are deliberately designed include Durand (2001); Brasseur et al. (2012); Air France Industries KLM Engineering & Maintenance (2013); Klauke et al. (2015).On a more general note, the problem of designing LRUs is relevant for firms that are responsible for operational aspects (downtime and the maintenance) of systems.Such a firm may be an Original Equipment Manufacturer (OEM) that closes service contracts with its customers, but it may also be a firm that sells Maintenance, Repair and Overhaul (MRO) as a service to the user.Examples of OEMs that consider the design of LRUs include PACCAR or Volkswagen Group (trucking industry), Airbus (aviation industry), and the aforementioned manufacturers ASML, Thales, and Canon; while examples of MROs that consider the design of LRUs include the aforementioned Dutch Railways and Air France Industries KLM Engineering & Maintenance (aviation industry).
LRUs are designed based on a given system design in practice.At an OEM, who designs the systems itself, the engineers design the system and subsequently they define the LRUs.The problem of defining the LRUs for a given design of the system is called LRU design.If development time allows, the OEM's design department may redesign their system design based on the outcome of a LRU design, and subsequently determine the LRUs again.A MRO does not design the system itself and thus starts with a given design of the system, when designing the LRUs.Similar to the OEM, the outcome of the LRU design may lead a MRO to modify the initial system design and derive the LRUs from this revised design.This interactive process between system design and LRU design is a powerful concept to reduce the total expected costs for an OEM or MRO.
A system consists of various critical parts that are all connected to each other.As soon as one of these parts fails, the entire system is down and the company incurs downtime cost.To reduce the downtime cost, it is essential to quickly restore the system to a functioning state by replacing the failed part.Firms typically group parts in LRUs such that each LRU can be replaced quickly if any of the parts in this LRU fails.As designers make larger LRUs, the purchase costs typically increase, because the LRU contains more parts and thus more value.The purchase cost can refer to the purchase cost of a new LRU or to the purchase cost of a repair depending on the context.
The failure of any part in a LRU triggers the failure of the entire LRU.The LRU's failure rate therefore equals the sum of the failure rates of the parts in the LRU1 .Larger LRU incur higher purchase cost and fail more often than smaller LRUs.Now, the challenge is to optimally design the LRUs such that the average costs per time unit are minimized.We address this problem in this paper when a LRU design is required to partition the parts into LRUs.The first reason for considering this partition constraint comes from interviews with our project partners.If parts are partitioned into LRUs, replacement ambiguity is avoided.Replacement ambiguity is the situation in which a part fails and it is contained in more than one LRU.The engineer can then decide what LRU to replace and this leads to each system being maintained differently, which is undesirable from an asset configuration management perspective.Secondly, partitioned LRUs simplify the OEM's/MRO's production and functional testing procedures of LRUs (van Geel, 2018, p. 19).A third reason for a partitioning constraint is that it is in line with common practice in engineering for reliability and maintenance Birolini (2007, p. 154).Nevertheless, the problem can also be solved without the partition constraint as shown in the appendix.In the remainder (Section 5) we numerically illustrate that the partition restriction leads to very limited increased costs, while it significantly increases the practical applicability of the LRU design.
Our LRU design problem relates to multi-component maintenance research with structural dependencies.Structural dependency between parts occurs when some parts have to be replaced or removed before the failed part can be replaced.Practitioners frequently face this type of dependency, but the academic field studying it "is wide open . . .and there have only been a few articles published on this topic" (Nicolai and Dekker, 2008).The problem of designing LRUs naturally falls into this class, and only two papers address this problem.Thomas (1986) poses the question whether to replace the entire car, the engine or just the piston rings in case the piston rings need replacement.More recently, Parada Puig and Basten (2015) have revisited the question posed by Thomas (1986) and propose a model to design LRUs based on a narrow set of potential LRUs.Both works start from a bill of materials structure, i.e., the system's structure is a tree.The major issue with tree structure is that it does not capture the structural dependencies between parts.Tree structures cannot model the connections that exist and that have to be broken in order to replace a failed part, i.e., the connections between parts need not adhere to a tree structure.By contrast, we focus on the connections (cables, hoses, bolt-nut connections etc.) between various parts in a system, i.e., we consider the structural dependencies between parts.We explicitly incorporate disassembly sequences that exist for maintenance based on connections.Literature typically considers part based disassembly sequences: Part B must be disassembled before part A can be disassembled (De Fazio and Whitney, 1987;Gupta and Krishnan, 1998;Lambert, 2007).This means that all connections that part B has with other parts have to be broken before the connections of part A can be broken that enable part A's replacement.We capture these disassembly dynamics by considering the connections between parts.The connection oriented disassembly sequence has a major benefit over the part based disassembly sequence: it allows a subset of a part's connections to be broken.For instance, if we want to replace the part A, connection based disassembly sequences allow a subset of part B's connections to be broken; whereas the part based disassembly sequence forces all connections of part B to be broken.Only breaking a subset of connections is common in practice -as observed at our project partners, e.g.part B can be tilted after unmounting the bolts and leaving a hose still attached to this part.Subsequently, a part A can be reached and replaced without fully Modelling the disassembly of a system based on its connections and the subsequent disassembly sequence is new and it enables us to accurately model the time needed to replace any LRU.Thus, we endogenize the replacement time and therewith the replacement cost of a LRU.This contrasts with Parada Puig and Basten (2015) where the replacement time and cost are exogenously given.Furthermore, our modeling considers the full set of potential LRUs, because a LRU -in our model -can be any combination of parts in the system, contrasting Thomas (1986) and Parada Puig and Basten (2015) who must pre-define all potential LRUs and their corresponding parameter values.
Another line of related research studies LRUs (which are called modules) from a systems engineering perspective, where "a module is a unit whose parts are powerfully connected among themselves, and relatively weakly connected to parts in other units" (Baldwin and Clark, 2000).This literature stream typically describes a system in terms of parts that are connected to each other, and these connections are commonly depicted in a Design Structure Matrix (DSM) (Steward, 1981).However, this approach neglects the disassembly sequence dynamics that exist for the replacement of LRUs (or modules).Papalambros and Michelena (1997) manage to relate this line of research to the area of optimization.Most research in the DSM stream aims to define measures of modularity and optimize these.Such measures typically focus on the connections between parts, and the measures prefer a high number of intra-LRU connections and a low number of inter-LRU connections; see Newcomb et al. (1998), Sharman and Yassine (2004), Sosa et al. (2007), and Wilschut et al. (2017).Optimization of of the defined measures is typically done by using genetic algorithms (Meier et al., 2006;Yu et al., 2007) or simulated annealing (Thebeau, 2001).The aforementioned research focuses on single product DSMs, whereas Alvaro and Harrison (2011) and Kim et al. (2021) apply this approach to a product family.
Work on (dis)assembly sequencing also has similarities to our work, because this stream models the (dis)assembly sequence that exists between parts in much detail (De Fazio and Whitney, 1987;Gupta and Krishnan, 1998;Lambert, 2007).Research in this area optimizes the (dis)assembly sequence.We do not optimize this sequence, but we consider it to be given and focus on optimizing the design of LRUs.
Finally, our work relates to several operations research studies that consider the impact of modular design on operations.These studies are often combinatorial in nature and aim to design product configurations such that the demand for end products is met and the average costs per time unit are minimized; see for example Swaminathan and Tayur (1998), Thonemann and Brandeau (2000), and Briant and Naddef (2004).The structure in their problems superficially resembles ours, because we also study configurations of parts, which are LRUs in our case.The main difference is that we model the connections between parts and the disassembly sequences that exist for maintenance, while research in this stream does not.
In this paper, we make the following contributions: we present (i) a novel way to represent a system with multiple parts that are connected to each other, and we incorporate the disassembly sequences that exist for maintenance based on connections rather than parts.Modeling the connections and disassembly sequences enables us to endogenize the downtime cost due to the replacement of a LRU containing the failed part.Next, we use our system description to define an optimization model -called LRU Design -that minimizes the sum of the replacement and purchase cost by optimizing the LRU designs.
We provide (ii) a set partitioning formulation of LRU Design that allows for branch-andprice algorithms.Next, we prove (iii) that an optimal solution to the set partitioning formulation is integer.This result is rather remarkable, because the feasible polyhedron is not integral.There exist two problems that also posses this property: a minimax transportation problem (Ahuja, 1986) and a multi-period machine assignment problem (Zhang and Bard, 2006).The majority of research typically shows the existence of an optimal integer solution by proving that the feasible polyhedron is integral (e.g. through total unimodularity), see for instance Hillier and Brandeau (1998), Ball et al. (2003), Churchill et al. (2012), Gamvros and Raghavan (2012).Our integrality result cannot be established in this way due to the non-integral polyhedron.We define a so-called LRU cycle and prove that a solution that contains such a LRU cycle is suboptimal.Subsequently, we study the matrix encoding of an optimal solution to prove that an optimal solution is integer.
We believe that our proof approach is applicable and promising to other problems that can be formulated as set partitioning problems, because one's main effort would be to prove suboptimality of partitions that contain cycles.Fourth (iv), we focus on additive failure rates such that we obtain linear expressions that support the implementation of our models.We specify the set partitioning formulation under such additive failure rates and we formulate LRU Design as a binary non-linear program (BNLP), which we then transform into a binary linear program.
Finally, (v) we illustrate that the set partitioning formulation is suitable for large instances, and we study the effects of various parameters on the model's outcome.Moreover, we numerically show that the relative cost impact of introducing a partitioning constraint is very limited, while we strongly improve practical applicability of our model.The rest of this paper is organized as follows.In Section 2, we discuss our system representation including the disassembly sequences, and the optimization model LRU Design.We present a set partitioning formulation of LRU Design in Section 3, and we prove that an optimal solution is integer for this formulation.In the succeeding part of the paper, we focus on additive failure rates (for implementation convenience) and we present the set partitioning formulation under this assumption.Moreover, we discuss a binary non-linear programming (BNLP) formulation of LRU Design in Section 4, which we subsequently linearize to obtain a binary linear program (BLP).Finally in Section 5, we numerically compare the computation times of the BLP formulation to the set partitioning formulation, we illustrate the effects of various parameter perturbations on the model's outcome, and illustrate the limited cost impact of the partitioning constraint in our problem.We offer concluding remarks in Section 6.

Model
First this section explains how a system with parts an connections can be represented by means of an example.The generalization then follows from the example and we present the optimization model called LRU Design.

An illustrative example
Consider a laptop repair shop that repairs laptops by removing failed parts from the laptop and replacing the failed parts with new ones.The repair shop's objective is to design the LRUs such that it minimizes the cost of repair time and procurement of new LRUs.We consider the illustrative example of a laptop, because this system is technologically simple and many people have some familiarity with it.Bear in mind however that the model was designed for and has greater financial impact for large and technologically complex systems.Unfortunately, such a system lacks the familiarity of general readership.
The laptop example is based on data for a Dell Precision 7710 laptop (Dell Inc., 2016).Each part has a purchase cost and a failure rate (in failures per year).Table 1 lists the estimated purchase cost and fictitious failure rate for all parts (in failures per year).The purchase cost of a part is its price found online on websites such as amazon.com.
Each of the parts is connected to other parts, e.g. the Palm Rest is screwed to the Computer Base, the Palm Rest is wired to the Motherboard, and the Palm Rest is screwed to the Keyboard.Thus, there exist connections {E, M }, {E, L}, and {C, E}.In the event the Palm Rest fails and one wishes to replace it individually, one has to break all the connections that the Palm Rest has with all other parts: {E, M }, {E, L} and {C, E}.Breaking each connection takes a certain amount of time, which translates into costs by multiplying the time with a cost rate, e.g. the salary rate of the repair man or downtime penalty.When the failed Palm Rest has been disconnected from the system, a new and identical Palm Rest from stock is installed into the system by reconnecting all the connections that have been broken previously (in order to remove the failed Palm Rest).This re-establishing of connections also costs time and can be translated into costs as well.Finally, a new Palm Rest is purchased to replenish the stock.
All information about parts, connections, failure rates, purchase costs, and the costs of breaking and re-establishing connections can be represented in a weighted un-directed graph.The parts correspond to vertices, and the part connections correspond to the edges.Furthermore, the failure rates and the purchase costs are attributes of the vertices, and the costs for breaking and reestablishing a connection correspond to the weight of an edge in the graph.For the laptop example, this graph can be found by analyzing the Owner's manual (Dell Inc., 2016)  The combination of the precedence graph (Figure 2) with the connection graph (Figure 1), enables us to list all connections that need to be broken for the replacement of an arbitrary part.For example, replacement the Palm Rest requires one to break {E, M }, {E, L}, and {C, E} (see Figure 1), but to break connection {C, E} one must first break the set of connections {{A, L}, {A, M }, {B, M }, {B, L}, {C, L}} (see Figure 2).Similarly, one can determine all connections that need to be broken prior to {E, M } and {E, L}.Furthermore, the LRU Q has a higher purchase cost as well as a higher failure rate compared to the Palm Rest and the Keyboard individually.Therefore, it is better to keep the Palm Rest and the Keyboard as separate LRUs instead of combining these two into one LRU Q.It is now of interest to find the optimal design of LRUs that minimizes the sum of the replacement and purchase costs, based on the connection graph in Figure 1 and the precedence graph in Figure 2.

A generic model
The example above illustrates how a system is built up and what relationships parts and connections have.The approach used for the laptop also applies to more complicated systems such as a bogie in a train (Bombardier/Dutch Railways), a positioning module in a lithography system (ASML), a truck engine (PACCAR/Volkswagen Group), or a jet engine (Pratt & Whitney).
Consider a system that consists of multiple parts, and assume that maintenance is done upon the failure of a part.Moreover, assume that one can accurately and instantaneously determine which part has failed, when the system fails as a whole.The system is defined by two graphs: a weighted undirected connection graph G and a directed precedence graph D. The graph G = (V, E) is characterized by the set of vertices V and the set of edges E. The former set V corresponds to the parts in the system, and the latter set E corresponds to the connections between parts.Furthermore, each part in G has a purchase cost ℓ : V → R + , where R + = {x ∈ R | x > 0}, and the failure rate for any subset Q ⊆ V is given by λ : 2 V → R + .We also assume that the failure rate function is superadditive, i.e., λ(R) The cost to break a connection are given by the edge costs w : E → R + .We use the terms part and vertex interchangeably, as well as the terms connection and edge.At the end of this section, we discuss what happens when LRUs are repaired rather than purchased, see Remark 1.
Besides the connection graph G, the precedence graph D = (E, A) is an unweighted acyclic directed graph that captures the disassembly sequences of the connections e ∈ E. The set A corresponds to the set of arcs, and an arc (i, j) ∈ A from edge i to edge j exists if and only if edge j has to be broken before edge i can be broken.We assume that arcs can only connect adjacent edges, i.e., all arcs in A satisfy ({u, v}, {v, x}) ∈ A : u, v, x ∈ V and u ̸ = v ̸ = x.The graph D determines a set H(e) of successor edges for each edge e ∈ E. This set H(e) consists of all edges including the edge e ∈ E that must be disconnected in order to break e, and it can be determined by using the polynomial time Algorithms 1 and 2 in Appendix A. We remark that H(e) is a directed tree rooted at e ∈ E.
Further, we assume that G is connected, without loss of generality.If G is not connected, there do not exist arcs ({u, v}, {x, y}) ∈ A such that u, v are in one connected component and x, y are in the other connected component.This follows because all arcs in A satisfy ({u, v}, {v, x}) ∈ A : Hence, if G were disconnected, we apply our model to each connected component of G with the precedence graph induced by the connected component.We define a LRU design as partition S of the vertices V .Connections need to be broken in order to replace a LRU Q ∈ S from the system.First, define the set the set of all edges that connect the LRU to the other parts of the system not in the LRU.That is, the set B(Q) contains the edges that cross the LRU's boundary.Next, for the removal of LRU Q, one must break all the edges e ∈ B(Q), as well as all the edges that need to be broken prior to breaking any edge e ∈ B(Q).Hence, Γ(Q) = e∈B(Q) H(e) is the set of edges that need to be broken in order to replace a LRU Q ∈ S. Note that Γ(Q) may contain edges between vertices in Q.This is a model feature as it allows us to model LRUs such as a chain between two cogwheels.If each each link in a chain is a vertex that is connected to the adjacent vertices, then it is necessary to break the edge between two links in order to remove the chain from the cogwheels.A detailed example of this is provided in Appendix B.
Each LRU Q has a purchase cost and failure rate.The purchase cost of a LRU is given by the sum of the purchase cost of all parts in the LRU, i.e., the LRU's purchase cost is given by v∈Q ℓ(v).We relax this assumption in Remark 1.The total failure rate of a LRU Q ∈ S is denoted by λ(Q).
Next, we derive the cost expression for a LRU Q ∈ S. Upon the failure of LRU Q, one breaks all edges e ∈ Γ(Q) resulting in the cost e∈Γ(Q) w(e).Moreover, replacement LRU is purchased at cost v∈Q ℓ(v).The average cost per time unit of LRU Q then satisfies (1) As a LRU design S is a partition of V and Q ∈ S, the total cost per time unit of a LRU design is given by The LRU Design problem can now be simply stated as: What is the LRU Design S that minimizes π(S)?
LRU Design has the property that each LRU Q in optimal solution S * to LRU Design is a connected subgraph of G.
Lemma 1.Each LRU Q ∈ S * is a connected subgraph of G, for any optimal solution S * to LRU Design.
Proof.Let S * be an optimal solution to LRU Design, and let J be the finite set of connected components in the subgraph induced by a LRU Q ∈ S * .The set J partitions Q, J is finite because Q is finite, and |J | ≥ 1.The case of |J | = 1 implies that Q is connected, which satisfies our claim.Thus, we consider the case |J | ≥ 2 in the remainder, and observe that in this case where the first inequality follows from the fact that each Γ(J ) ⊆ Γ(Q), ∀J ∈ J .The second inequality follows from the fact that J ⊂ Q, ∀J ∈ J , and thus u∈J ℓ(u) < u∈Q ℓ(u), ∀J ∈ J .
The last inequality holds because J partitions Q and the failure rate function λ is superadditive.
Hence, we obtain J ∈J ω(J ) < ω(Q), where J partitions Q.However, this contradicts the optimality of S * .Therefore, each LRU Q ∈ S * is a connected subgraph of G, for any optimal solution S * to LRU Design.
We will use Lemma 1 throughout this paper.We conclude this section with two remarks that enable further generalization of LRU Design.
Remark 1.We assumed that we do not repair a LRU, and thus purchase a new one.If we relax this assumption and repair a failed part of a LRU offline, we incur a total repair cost per time unit of λ(V ) v∈V q(v), where q(v) is the repair cost of part v.However, if we repair a part of a LRU, we have to test the entire LRU to see whether it functions again.This means that we have to test each part in the LRU, and thus ℓ(v) now represents the cost of testing part v ∈ V offline.Larger LRUs, now, have more parts that need to be tested before the LRU is certified as repaired.
The total repair cost per time unit is sunk as λ(V ) v∈V q(v) is independent of the LRU design, but we still have the testing cost per time unit of LRU Q given by λ(Q) u∈Q ℓ(u).Hence, our model LRU Design still applies.

Set partitioning formulation
We formulate LRU Design as a set partitioning problem that allows for column generation (branch-and-price) algorithms.Then, we prove in Section 3.1 that an optimal solution to the relaxed master program is integer, even though the feasible polyhedron is not integral.Finally, we present the column generating procedure in Section 3.2 for solving the set partitioning formulation of LRU Design.
A LRU design S consists of various non-intersecting LRUs Q ∈ S that have been selected.
Let S = 2 V be the power set of V from which LRUs can be selected; S contains all possible LRUs.Then, S ⊂ S , and our objective is to determine which solution S is optimal via column generation.A LRU Q ∈ S can equivalently be represented as a (0, 1) column with |V | elements, where a 1 indicates that a vertex is in the LRU Q and a 0 denotes that the vertex does not belong to the LRU Q.Hence, we consider the matrix entries z vQ that equal 1 if v ∈ Q and 0 otherwise.
Then, a column from the matrix Z = (z vQ ) corresponds to LRU Q, and we denote this column by Z Q .Note that a column Z Q and the LRU Q ⊆ V are equivalent representations of a LRU.Let x Q be the indicator variable that denotes whether a LRU Q ∈ S is selected for the LRU design S. We denote x as the vector consisting of all entries x Q .Given x, we can straightforwardly derive the solution S to LRU Design by S = {Q ∈ S : x Q > 0}.We remark that S can equivalently be represented as the submatrix Z = {Z Q : x Q > 0} of Z.Our objective is to determine the LRU design in terms of x Q such that the average costs per time unit are minimized, and each part v ∈ V is included in exactly one LRU.We capture this in the Master Problem (M): Recalling that ω(Q) is the average cost per time unit of using LRU Q, the objective function (3a) minimizes the costs of using the selected LRUs, while constraints (3b) enforce that each part The set S is exponentially large, so straightforward optimization is not tractable.Therefore, we propose to solve the LP relaxation of M by column generation.We relax the integrality of x Q to obtain the LP relaxation of the Master Problem called LPM: Subsequently, we present our procedure for solving LPM in Section 3.2.

Integrality and polyhedral structure of LPM
We prove that an optimal solution to LPM is integer by considering a so-called LRU cycle.We show that if a given fractional solution contains a LRU cycle, there exists a feasible solution to LPM without the LRU cycle and strictly lower costs.This implies that an optimal solution does not contain a LRU cycle.
Let x be a fractional solution to LPM with S = {Q ∈ S : xQ > 0} (or equivalently Z = {Z Q : xQ > 0}) and such that each Q ∈ S is a connected subgraph of G. Furthermore, let x * be an optimal solution to LPM with S * = {Q ∈ S : ) and that also has connected LRUs Q ∈ S * .Note that x * exists by Lemma 1.
For an example of a LRU cycle, we refer the reader to Figure 3.We remark that there can exist a solution containing a LRU cycle such that the solution is an extreme point of the feasible polyhedron of LPM, and thus the feasible polyhedron of LPM is not integral.Next, we prove that an optimal solution to LPM does not contain a LRU cycle: 2. Theorem 2. An optimal solution x * to LPM does not contain a LRU cycle.
The proof of this theorem uses a technical lemma that can be found in the appendix D as Lemma 5 and the following two concepts.Define the set of edges that is broken for a LRU X but not for a LRU Y by F(X, Y ) = Γ(X) \ Γ(Y ).Furthermore, modular arithmetic is used for the indices of LRUs that form a cycle Q i , Q i−1 , and Q i+1 with 1 ≤ i ≤ n, n + 1 ≡ 1 (mod n), and Proof.We show that a solution to LPM that contains a LRU cycle is suboptimal.Let x be a solution to LPM such that each Q ∈ S is connected and there exists a LRU cycle C = {Q 1 , Q 2 , . . ., Q n } ⊆ S with minimal n.Note that a solution that contains a LRU cycle must be fractional.We prove that there exists a feasible solution x ′ to LPM with S ′ = {Q ∈ S : x ′ Q > 0} in which the LRU cycle C does not exist and π(S ′ ) < π( S).
w(e) for each LRU Q j .Next, we consider a specific LRU Q i = argmin Q j ∈C {W j } and we assume that We create an alternative solution x ′ by partitioning That is, let the alternative solution x ′ be identical to x except for the entries where the first inequality follows from the superadditivity of λ and the second inequality holds as , and ℓ(v) > 0 for all v ∈ V .The last inequality follows after rearranging terms and using the superadditivity of the failure rate function λ.We continue by proving that the right hand side of the last equality is less than zero; i.e., we show w(e) The equality holds, because The second inequality holds by Lemma 5.The last inequality follows because and we assumed that Hence, x ′ is a solution without the LRU cycle C and satisfies π(S ′ ) < π( S).
Next, consider the case Then, we create the solution x ′ by parti- , and we follow the same procedure as above using Lemma 5 and Hence, the solution x ′ does not have the LRU cycle C and satisfies π(S ′ ) < π( S).
The result of Theorem 2 is illustrated by means of Example 1.
Example 1. Suppose we have the connection graph G with w(e) = 1, ∀e ∈ E and the precedence graph D from Figure 3. Furthermore, we consider the solution x with a LRU cycle C ⊆ S as drawn by the dashed ellipses in Figure 3.We illustrate our procedure for splitting LRU a Q i into In this example, we have One can use the above expressions to verify that the procedure in the proof of Theorem 2 yields a solution x ′ such that π(S ′ ) < π( S). ⋄ Next, we introduce the concept of totally balanced matrices and Theorem 3 that -in combination with Theorem 2 -helps us to prove that an optimal solution to LPM is integer.The definition of a totally balanced matrix can for instance be found in Anstee and Farber (1984) or Hoffman et al. (1985).
Definition 2. A binary matrix R is totally balanced if it does not contain a square submatrix R that has no identical columns and the sum of each row and column equals to two.
Given this definition, we can now introduce Theorem 3, stating that the matrix encoding of an optimal solution to LPM is totally balanced.Note that we do not consider the constraint matrix of LPM -as is mostly done -but we study the matrix encoding of an optimal solution to LPM.
Theorem 3. If an optimal solution x * does not contain a LRU cycle, then Z * is totally balanced.
Proof.By the definition of a totally balanced matrix the statement of this theorem is equivalent to: Given an optimal solution x * -with S * or equivalently Z * -that does not contain a LRU cycle, there does not exist a binary k × k submatrix R of Z * with k ≥ 3, no identical columns, and such that the sum of each row and column of R equals to two.We prove this by the contraposition, i.e. we prove that if such a submatrix exists, the solution contains a LRU cycle.
To be more precise, we prove the following statement: Given a binary k × k matrix R with k ≥ 3, no identical columns, and such that each row and column sum to two, there exists an n × n submatrix R of R with minimal n ≥ 3, no identical columns, and such that each row and column of R sum to two.If we interpret the columns of R as LRUs and the rows of R as vertices, then the LRUs -corresponding to the columns of R -are a LRU cycle.
Consider an n × n submatrix R of R with minimal n ≥ 3, no identical columns, and such that each row and column of R sum to two.Such a submatrix R exists, because R satisfies the same conditions.We will rename the rows and columns of R such that we can easily show that the columns (LRUs) of R are a LRU cycle.This renaming procedure is as follows.
The first row is v 1 and Q 1 and Q 2 are the columns such that rv 1 ,Q 1 = rv 1 ,Q 2 = 1.This follows without loss of generality, because R is binary and the sum of each row equals two.Furthermore, note that all other values of v 1 are zero.Next, let v 2 be the second row such that rv 2 ,Q 2 = 1.This is feasible because the sum of column Q 2 is two.Moreover, all other rows (except v 1 and v 2 ) have the value 0 in column Q 2 .We also remark that rv 2 ,Q 1 = 0, since otherwise all other values in column Q 1 (except for rv 1 ,Q 1 and rv 2 ,Q 1 ) are zero and this means that columns Q 1 and Q 2 are identical, which is a contradiction.
Next, we label the column Q i such that rv i−1 ,Q i = 1 for each i = 3, . . ., n, and we call the row v i that satisfies rv i ,Q i = 1, for all i = 3, . . ., n.This can be done due to the following reasoning.
The columns Q j with 1 < j < i − 1 are such that rv i−1 ,Q j = 0, because each column Q j already sums to two.Unless i = n, we have rv i−1 ,Q 1 = 0 because otherwise we would have a i × i submatrix for which each row and column sum equal 2, i ≥ 3, and where no identical columns exists.But this would contradict the fact that n is minimal.Hence, we can label Moreover, all rows v j with 1 ≤ j < i − 1 are such that rv j ,Q i = 0, because each row v j already sums to two (by considering columns Q k with k < i).Therefore, we can call a row v i such that Finally, we let r vn,Q 1 = 1 such that the row and column sum of each row and column of R equals 2.
Given the renaming of the columns and rows of R, we have for all 1 Hence, we proved that the submatrix R corresponds to a LRU cycle.Hence, if an optimal solution x * does not contain a LRU cycle, it will not contain such a submatrix and, thus, the matrix Z * is totally balanced.
Given Theorem 2 and Theorem 3, our final and rather unusual result follows relatively easily in Theorem 4.
Theorem 4. All extreme optimal points of the feasible polyhedron of LPM are integer.
Proof.Proof.Let x * be an optimal solution to LPM.Each LRU Q ∈ S * is a connected subgraph of G by Lemma 1 and x * does not contain a LRU cycle by Theorem 2.Then, the matrix Z * is totally balanced by Theorem 3. Consequently, the polyhedron P = x : is integral (Fulkerson and Hoffman, 1974).Hence, x * is either integer or a convex combination of integer solutions to LPM, and thus we obtain our desired result.
In a column generation approach, a restricted version of LPM is solved repeatedly after new columns are added (this will be detailed in Section 3.2).If the restricted versions of LPM are solved by the simplex algorithm, we obtain an optimal solution x * that is an extreme point of the polyhedron P = x : Zx = 1, x ≥ 0, x ∈ R |S | , but is also an extreme point of the polyhedron spanned by the submatrix Z * .Theorem 4 now implies that x * is integral, because x * is an extreme point of P. Hence, solving LPM with the simplex algorithm yields an optimal integer solution, and this solution is thus also optimal for M.
If LPM is solved by the simplex algorithm, we obtain an optimal solution x * that is an extreme point of the polyhedron P = x : Zx = 1, x ≥ 0, x ∈ R |S | , but is also an extreme point of the polyhedron P = x : Z * x = 1, x ≥ 0, x ∈ R |S * | spanned by the submatrix Z * .Theorem 4 now implies that x * is integral, because x * is an extreme point of P. Hence, solving LPM with the simplex algorithm yields an optimal integer solution, and this solution is thus also optimal for M.
We would like to stress that our result in Theorem 4 is rather unusual, because the polyhedron P of LPM is not integral.This contrasts with much other research that focuses on proving integrality of the polyhedron to conclude that an optimal integer solution can be found (if the objective function is convex), e.g.via totally unimodular constraint matrices.We demonstrate that -for non-integral polyhedra -analysis of the objective function can be used to establish the existence of an optimal integer solution to a relaxed problem when the constraint matrix will not guarantee an integral polyhedron.The crucial analysis of the objective function is in the proof of Theorem 2. We believe that our proof approach can be used more generally for partitioning problems where the objective function is convex.One is only required to show that cycles in solutions are suboptimal.

Solving LPM and M
Given Theorem 4, we move our attention to solving LPM, for which we apply column generation.
Hence, we consider a feasible subset of LRUs (or columns) S ⊆ S for LPM.This results in the Restricted Master Program (RLPM).For RLPM, we generate profitable LRUs (columns) by solving the pricing problem of RLPM: where r v are dual variables for the partitioning constraints of RLPM.We want to find a LRU Q ∈ S with minimal reduced cost.After we solve the pricing problem (7), we add the obtained LRU to S and we again solve LPM with the new S .Next, we solve the pricing problem again, and we repeat this procedure until the pricing problem does not return a profitable LRU (column), i.e., we terminate when c * ≥ 0. This means that there does not exist a LRU (column) that is worthwhile to add to our LPM, and we have obtained the optimal solution.
The computation of the pricing problem is difficult in general, but can be done with a standard solver when the failure rate function λ is additive, i.e., when λ(S) = i∈S λ({i}).We provide this formulation below.

Pricing problem for additive failure rates
Problem (5) can be expressed as follows when λ is additive (λ(S) = i∈S λ({i})).The binary auxiliary variable k e denotes whether edge e ∈ E needs to be disconnected to remove LRU Q.The binary decision variable γ v indicates whether node v is included in the LRU Q.Now we rewrite Problem (5) to obtain Problem ( 5) can be linearized by applying the McCormick linearization method (McCormick, 1976).In particular, let η ev = k e γ v and δ uv = γ u γ v .Note that η ev denotes whether the LRU contains part v ∈ V and that edge e ∈ E needs to be broken for the LRU to be removed.
Similarly, δ uv represents whether the LRU contains both parts u, v ∈ V .Then a binary linear formulation of ( 5) is given below in(7).
After we solve the pricing problem ( 7), we add the obtained LRU to S and we again solve LPM with the new S .Next, we solve the pricing problem again, and we repeat this procedure until the pricing problem does not return a profitable LRU (column), i.e., we terminate when c * ≥ 0. This means that there does not exist a LRU (column) that is worthwhile to add to our LPM, and we have obtained the optimal solution.

Binary programming formulation an additive failure rate function
In this section, we consider only additive failure rates λ, i.e. λ(Q) = v∈Q λ({v}).This special case is convenient when implementing the model and solving it with a standard solver like CPLEX or Gurobi.We formulate LRU Design as a binary non-linear program (BNLP) and linearize it so that it can be solved by a standard integer program solver.We use this linearlized binary linear Program (BLP) as a benchmark to compare our set partitioning formulation with.
For the BNLP, we first relax the fact that ∅ ̸ ∈ S. In the foregoing, S was a partition of V .
For the BNLP (and later the BLP) we consider a solution We denote Y as the matrix consisting of all entries y vi .Note that we can derive S ′ easily from Y .We also define the auxiliary binary variable k e i that denotes whether edge e ∈ E needs to be broken in order to replace LRU Q i , and organize them in a matrix K.We determine the value of k e i by considering all the edges b ∈ B(Q i ).We determine B(Q i ) by considering the edges {u, v} ∈ E such that y ui − y vi = 1 or y vi − y ui = 1, i.e., one of the end points of {u, v} belongs to LRU Q i while the other end point does not.This corresponds to the definition of B(Q i ).Subsequently, we consider each edge e ∈ E that needs to be broken before breaking {u, v}; i.e., for each {u, v} ∈ B(Q i ) we consider all e ∈ H({u, v}).Hence, the variable k e i satisfies y ui − y vi ≤ k e i , ∀{u, v} ∈ E, ∀e ∈ H({u, v}), ∀i ∈ {1, . . ., |V |}.Note that k e i may take the value of one, even if an edge e ∈ E is fully contained within a LRU Q i .We denote K as the matrix consisting of all entries k e i .We use the variable k e i in our objective function (8a), since it represents whether an edge has to be broken (k e i = 1) in order to remove LRU Q i .Furthermore, the objective function implies k e i = 0 if edge e is not broken for the replacement of Q i .Next, we use k e i , the edge weights, and the failure rate of Q i (expressed using y vi ) to determine the cost for replacing Q i .
The total purchase cost of the LRU Q i is derived by using y vi , and we multiply this by the total failure rate of Q i (which also depends on y vi ).This results in a binary non-linear programming formulation of LRU Design: Constraints (8b) ensure that each part v ∈ V is included in exactly one LRU, and constraints (8c) enforce the definition of the auxiliary variable k e i .The BNLP is a problem with a quadratic objective function.Therefore, the BNLP van be linearized by the McCormick reformulation (McCormick, 1976); i.e., we introduce new variables ρ i ev = y vi k e i and σ i uv = y ui y vi .The variable ρ i ev denotes whether LRU Q i contains part v ∈ V and whether edge e ∈ E needs to be broken in order to replace the LRU Q i .Analogously, σ i uv denotes whether two parts u, v ∈ V are both contained in the same LRU Q i .Substituting ρ i ev and σ i uv into the above implies that we need to add constraints that enforce the interpretation we gave.
Furthermore, we optimize over Y , K, ρ and σ, where ρ and σ correspond to the 3-D arrays with entries ρ i ev and σ i uv , respectively.Hence, we obtain the BLP formulation of LRU Design: We acknowledge that tighter MIP formulations than BLP will exist due to extensive studies on binary quadratic programming and boolean quadratic polytopes (Padberg, 1989;Boros et al., 1992;Boros and Hammer, 1993;Deza et al., 1997;Rendl et al., 2010;Bonami et al., 2018;Jünger and Mallach, 2021;Charfreitag et al., 2022;Rehfeldt et al., 2023).The formulation above is a straightforward formulation that will appeal to many practitioners of operations research due to its simplicity.

Numerical experiments
In this section, we use the binary linear program (BLP) formulation and the set partitioning formulation (LPM) of LRU Design under additive failure rate functions to gain some insight into the size of instances that can be solved to optimality.We shed a light on the objective value gap between both approaches, and we explore the effects of parameter perturbations on our model's outcomes.Furthermore, we numerically illustrate -based on randomly generated instances of practical size -that the relative cost increase from introducing a partitioning constraint is very limited, and its magnitude decreases as the number of parts grows.We have implemented all optimization model formulations in JuMP (Lubin and Dunning, 2015;Dunning et al., 2017), which is a mathematical optimization package of Julia (Balbaert et al., 2016), and we solved all problems using Gurobi 7.0.1 on an Intel i5-4300U @2.50GHz processor with 16GB RAM and running Ubuntu 16.04 LTS.
In Section 5.1, we explain the used instance generator for our experiments.In Section 5.2 we study the difference between the computation times (in seconds) of the binary linear programming formulation (BLP) and the set partitioning formulation (LPM).Also, we discuss the relative difference in objective value between both models.Furthermore, we shed some light on how the downtime cost per time unit affects the number of LRUs used in an optimal solution.Moreover, we study how the system's complexity affects the total annual costs by considering the number of connections between parts, and the number of predecessor-successor relationships that exist.
Finally, we show that the cost effect of introducing a partitioning constraint is very limited for practically sized instances.
We use a time limit of 600 seconds for the BLP formulation and also for the set partitioning formulation.This time limit is relatively low because we solve a large number of instances, thereby making it feasible to perform the entire numerical study in a reasonable amount of time.If an instance has not been solved to optimality within 600 seconds, we say that it is inefficient.If all instances of a certain parameter combination (|V |, δ, δ E ) are inefficient, we write -as an entry for the combination.We determine the average computation time of both formulations based on the efficient instances.The results are presented in Table 2, where the computation times are given in seconds, and the subscripts indicate the number of efficient instances.Furthermore, we have not reported computation times for the BLP with |V | ≥ 40, since we have found no efficient solutions within the time limit.
We observe that, given the time limit of 600 seconds, the BLP formulation can only solve small size instances up to 20 vertices (parts), while the set partitioning (SP) formulation can solve medium size to large instances up to 60 vertices (parts).Furthermore, we see that the set partitioning formulation solves instances faster than the BLP formulation.This effect is amplified when the instances become larger, i.e., when |V | and δ increase.Real-life instances are typically medium to large sized instances and can have 50 vertices (parts).Furthermore, such instances may possess many and complex connections and predecessor-successor relationships.This makes the BLP formulation unsuitable for practical purposes.Hence, it is worthwhile to invest extra time to implement the set partitioning formulation (LPM) with a pure pricing algorithm.Furthermore, the computation times illustrate that the set partitioning formulation of LRU Design is particularly useful as a feedback mechanism for the company's design department.The engineers can quickly assess many design alternatives (in terms of the connection graph and precedence graph) and their effects on the optimal LRU design and the corresponding (after-sales) costs.Not solving the BLP formulation to optimality may still result in solutions that are near optimal.Therefore, we also perform a gap analysis by studying the relative difference in the objective values of both formulations.We only study this difference for parameter combinations for which each instance solved by LPM is efficient, i.e., instances with |V | ≤ 40.We define the objective value gap with π(S b ) and π(S l ) denoting the costs of the best feasible solution found after 600 seconds of the BLP and set partitioning formulation (LPM), respectively.The results are shown in Table 3.We observe that the relative objective value difference rapidly grows as the number of vertices grows.This implies that the inefficient instances, produced by the BLP, do not result in a competitive solution compared to the set partitioning formulation (LPM).
Next, we numerically study the effect of the cost of one time unit of system downtime on the number of LRUs that is used in an optimal LRU design.In the remainder of this section, we use the same instance generator as discussed in Section 5.1, and we generate 1,000 instances per parameter setting (δ, δ E ) and keep |V | = 20.For a given instance, we vary the edge weights by multiplying all edge weights of the instance by a constant factor q ∈ {0.1, 1, 10}.A higher value for q means that it is more expensive to break edges.If the time for breaking an edge remains constant, it means that the cost rate per time unit for breaking an edge increases, and thus we can capture a higher downtime cost per time unit by varying q.This way, we create three classes of instances (i) low downtime cost per time unit (q = 0.1); (ii) moderate downtime cost per time unit (q = 1); (iii) and high downtime cost per time unit (q = 10).We keep the parameter values for δ and δ E constant at δ = 3 and δ E = 1.We focus on the number of LRUs |S * | in an optimal solution S * .The results are presented in Figure 4. Based on Figure 4, the instances where the downtime cost per time unit is low, have many small LRUs (each part is a LRU in itself in the extreme case).These solutions prefer small LRUs because they have lower purchase costs.As the cost for a single time unit of downtime increases, we see that the optimal solution prefers fewer LRUs that each become larger, because such larger LRUs enable faster replacement and thus lower downtime costs.This explains, for example, why we observe that the consumer electronics industry with low values for q has rather small LRUs.
On the other end of the spectrum, capital intensive industries such as the semiconductor industry or the aviation industry have high values for q, and they tend to opt for larger LRUs which enable faster replacement.Both these phenomena are confirmed by the numerical results of our model.
The second effect that we study considers the complexity of the system, and how this affects the costs of the optimal LRU design.We restrict our attention, for now, on the number of edges in the connection graph G that describes system complexity.We vary how strongly various parts are connected to each other by altering δ.A low (high) value of δ corresponds to lesser (more) connected parts.We are interested in the effect that the number of connections in G has on the costs, because this provides a justification of whether to avoid many connections between parts in order to reduce the total cost.For our analysis, we keep δ E and q constant at δ E = 1 and q = 1.
The results are presented in Figure 5.We observe that more connections in the connection graph G result in cost increases, because we need to disconnect more edges in order to remove a LRU.This has an important managerial implication, as engineers should be urged to reduce the number of connections in systems to be developed.Thus, it may be wise for a company to invest extra in a system's design such that the number of connections in G is reduced.An example wherein few number of connections lead to low costs is a bicycle.A typical connection graph of bicycles has few connections, and consequently relatively low replacement cost because we only need to disconnect few connections in case a part fails.
Finally, we also study the effect that system complexity has on the costs of the optimal solution π(S * ), when we consider the number of predecessor-successor relationships.A lower value of δ E indicates that fewer predecessor-successor relationships exist in the precedence graph D. Similar to the foregoing, we keep the other parameters constant at δ = 3 and q = 1.The results for different values of δ E are depicted in Figure 6 and we observe a similar behavior to changes in δ.
The costs increase as the number of predecessor-successor relationships increases, because we need to disconnect more connections upon the failure of a LRU.Consequently, the costs of an optimal solution π(S * ) increase when the number of connections in D increases (as δ E increases).
The managerial implications of our results also align with those for δ: managers should urge their designers to avoid predecessor-successor relationships in order to reduce costs.This objective may be easier to attain than avoiding connections in the connection graph G by careful design.Hence, × 100%, where S * and S * c are the optimal solutions of LRU Design and C-LRU Design, respectively.We limit our analysis to instances with |V | ∈ {20, 30, 40}, because the set partitioning formulation of LRU Design is efficient for each parameter combination.
The results in Table 4 illustrate that we sacrifice little costs when we introduce a partitioning constraint.Combining this with the practical benefits that LRU Design has over C-LRU Design, we conclude that LRU Design is highly usable for practical purposes.

Conclusions
We considered an OEM or MRO that is concerned with the (re)design and maintenance of a system.If the system does not operate, the company loses money, customer goodwill or has to pay customers a downtime penalty.Therefore, the company is interested in lowering the cost for non-functioning systems by designing Line Replaceable Units (LRUs) that can be removed quickly.Furthermore, the LRUs should not be too large, because this increases a LRU's total  failure rate and the LRU's purchase cost (or repair cost).Thus, the company has to determine what the optimal LRU design is that balances the replacement cost and the purchase cost (or repair cost) of LRUs.
We presented a novel model for representing the connections between parts in a system, also capturing the existing disassembly sequences.We used the system representation to derive an optimization model LRU Design that minimizes the replacement cost and the purchase cost (or repair cost) by optimizing the LRU design.Our optimization model was constrained such that a LRU design is a partition of the parts, and we saw that this constraint has strong practical benefits (avoiding replacement ambiguity, simplification of the production and testing processes, and consistency with general maintenance practice), while sacrificing very little extra costs compared to the case where we relax the partition constraint.We formulated the problem as a binary linear program and as a set partitioning problem.We proved a result infrequently encountered in research: an optimal solution to the set partitioning formulation is integer, despite a non-integral feasible polyhedron.This result follows from proving the suboptimality of LRU cycles and relating this to the matrix encoding of an optimal solution.Furthermore, the set partitioning formulation reduces the computation times and makes it useful as a feedback mechanism to assess various design alternatives and their effects on the optimal LRU design and the corresponding (after-sales) costs.Moreover, the set partitioning formulation is suitable to solve large instances, while the binary linear programming formulation is not.In addition to the computation times, we observed that optimal solutions to LRU Design have larger LRUs when the cost per time unit of system downtime increases, because this enables faster replacement and thus avoids large downtime cost.
Finally, we found that managers should urge their designers to reduce the number of connections and predecessor-successor relationships in a system's design.
Algorithm 1 Derive H(e) for all edges e ∈ E 1: procedure RemovalEdges(E, A) 2: Ê ← E 3: Ẽ ← Degree(D( Ê, A)) 4: while Ẽ ̸ = ∅ do 5: for all e ∈ Ẽ do 6: H(e) ← {e} 7: end for 8: for all e ∈ Ẽ do end for 8: return Ẽ 9: end procedure This example can be formalized in the connection and precedence graph shown in Figures 8   and 9 respectively.In these graphs A and B are the cog-wheels and nodes 1 to 12 correspond to the links in the chain.In this example the chain LRU is given by Q = {1, 2, . . ., 12} so that Γ(Q) = {{A, 3}, {B, 3}, {3, 4}}.The fact that that {3, 4} is internal to chain reflects the fact that it is physically impossible to remove the chain from the cog-wheels without first breaking a connection between two links in the chain.Thus the precedence graph models the physical necessity of breaking certain connections before it is possible to break/access other connections.
The fact that Γ(Q) may contain connections that are internal to an LRU Q is a modeling feature that allows us to model systems appropriately.However, we do observe that most LRUs in optimal designs do not have internal connections that need to be broken.A part v ∈ V belongs to at least one LRU.That is, part v is replaced upon its own failure, but it may also be replaced upon the failure of a part u ∈ V : u ̸ = v.Therefore, we represent a LRU differently from LRU Design.We let a LRU be a tuple characterized by a replacement set and a failure set, i.e., Q = The failure rate of LRU Q is given by v∈F Q λ(v), because all parts v ∈ F Q induce the replacement of R Q .Similarly, the total purchase cost of LRU Q is given by v∈R Q ℓ(v).This yields the following average cost per time unit for LRU Q: We are interested in determining the optimal LRU design.Let S c be a collection of LRUs such that ∅ ̸ ∈ S c and each part v ∈ V is included in at least one replacement set and in exactly one failure set; i.e., Q∈Sc F The average costs per time unit of a LRU design S c are given by Next, we define C-LRU design as: What is the LRU Design S c that minimizes π c (S c )?
For implementation, we use the binary programming formulation of C-LRU Design as explained in Driessen (2018), which is similar to the binary programming formulation of LRU Design.

D. Lemma used in the proof of Theorem 2
The proof of Theorem 2, which states that an optimal solution to LPM does not contain a LRU cycle, uses Lemma 5.This appendix contains the statement, an interpretation and the proof of that lemma.Recall that we define the set of edges that is broken for a LRU X but not for a LRU Y by F(X, Y ) = Γ(X) \ Γ(Y ).Furthermore, recall that we use modular arithmetic for the indices of LRUs that form a cycle Q i , Q i−1 , and Q i+1 with 1 ≤ i ≤ n + 1 ≡ 1 (mod n), and Q 0 ≡ Q n .
Lemma 5. Given a solution x to LPM that contains a LRU cycle C = {Q 1 , Q 2 , . . ., Q n } ⊆ S with minimal n, we have Lemma 5 can be interpreted by considering Figure 10, which is a simplified part of a solution in which we depict only the LRUs Q i−1 , Q i , and Q i+1 , and we assume that A = ∅.The first claim in Lemma 5 states that the set of edges that are broken for LRU Q i as well as for the intersection Q i ∩ Q i+1 (the edges that cross the thin dotted line in Figure 10) is a subset of the edges that are broken for Q i except for the edges that are broken for Q i ∩ Q i−1 but not for Q i−1 (the edges that cross the thin solid line in Figure 10).Secondly, the set of edges that is broken for both Q i and Q i \ Q i+1 (the edges that cross the thick dotted line in Figure 10) is a subset of the edges that are broken for Q i except for the edges that are broken for Q i ∩ Q i+1 but not for Q i+1 (the edges that cross the thick solid line in Figure 10).The third and fourth claim from Lemma 5 can be interpreted similarly to the first two claims, where Q i+1 is replaced by Q i−1 and vice versa.
The same interpretation -as illustrated in Figure 10 -holds when A ̸ = ∅, but this makes exposition cumbersome.The proof of Lemma 5 is given below, for arbitrary A.
Hence, if e ∈ Γ( and Q i \ Q i+1 partition Q i , and thus the edges existing between where the last inequality holds as . Finally, we have Finally, we can do the same analysis as above, but replace Q i−1 by Q i+1 and vice versa.Then,

Figure 2 :
Figure 2: The laptop's precedence graph Finally, one must break all connections {{A, L}, {A, M }, {B, M }, {B, L}, {C, E}, {C, L}, {E, L}, {E, M }} in order to remove the Palm Rest (E).Analogously, one must break connections {{A, L}, {A, M }, {B, M }, {B, L}, {C, E}, {C, L}} to replace the Keyboard.If one decides to replace the Palm Rest (E) together with the Keyboard (C), i.e., define a LRU Q that contains C and E. However, this implies that the engineer has to break all connections {{A, L}, {A, M }, {B, M }, {B, L}, {C, L}, {C, E}, {E, L}, {E, M }} upon the failure of either the Palm Rest (E) or the Keyboard (C).As a consequence, one must break the expensive edges {E, L} and {E, M } more often than when the Palm Rest and the Keyboard are separate LRUs.

Figure 3 :
Figure 3: The input graphs and a LRU cycle C An instance is described by the graphs G and D. We vary the number of vertices |V |, the number of edges |E|, and the number of arcs |A| in our numerical experiments.We relate the number of edges in G to the number of vertices by |E| = δ|V |, where δ is the average vertex degree in the graph G. Similarly, we relate the number of arcs in D to the number of edges by |A| = δ E |E|, where δ E is the average out degree of an edge e ∈ E. All other parameters such as λ(v) > 0 and ℓ(v) > 0 for all v ∈ V , and w(e) > 0 for all e ∈ E are randomly generated, as well as a graph's layout in terms of the edge set E and the arc set A. The graphs G and D are generated in the following way.For G, we have a set of vertices V and a number of unique edges |E| = δ|V |, and we create a spanning tree with |V | − 1 edges.We add an arbitrary vertex v ∈ V to a set of considered vertices Ṽ , and we select a new vertex u ∈ V \ Ṽ and connect it to an arbitrary vertex z ∈ Ṽ by adding the edge {u, v} to the edge set E. We keep doing this until Ṽ = V .Subsequently we add remaining edges randomly to our graph and we terminate once we have |E| edges in G. Secondly, we generate the precedence graph D. We (randomly) assign an index to each edge e ∈ E and denote this index by I(e), and the minimum and maximum values assigned are 1 and |E|, respectively.We start with A = ∅ and add an arc in each iteration.An iteration starts by selecting two random edges {u, v}, {v, x} ∈ E : u, v, x ∈ V and u ̸ = v ̸ = x.If I({u, v}) ≤ I({v, x}) we create an arc ({u, v}, {v, x}) and add it to A, otherwise we create an arc ({v, x}, {u, v}) and add it to A. We repeat this procedure until δ E |E| = |A|, and upon termination we have obtained a set A that has a topological sorting and thus the precedence graph D is acyclic.

Figure 4 :
Figure 4: Effect of edge weights on the number of LRUs in S *

Figure 5 :
Figure 5: Effect of the number of connections in G on π(S * )

Figure 6 :
Figure 6: Effect of the number of predecessor-successor relationships in D on π(S * ) Determine all edges e ∈ E that have no successors in D 1: procedure Degree(D)

Figure 7 :Figure 8 :Figure 9 :
Figure 7: Two cog-wheels connected a chain failure set.The failure of a part in the failure set triggers replacement of the LRU.The replacement set is replaced if any of the vertices in the failure set fails.Furthermore, we assume that a part v ∈ V belongs to exactly one failure set, i.e., the failure sets partition V .Next, we study what happens when a LRU Q fails, or technically what happens when a part v ∈ F Q fails.In this case, we have to break all edges e ∈ Γ(R Q ), where Γ

Figure 10 :
Figure 10: Interpretation of Lemma 5.The edges that cross the lines shown in the legend are contained in the corresponding sets of the legend.

Table 1 :
Part identifier listWe call the graph in Figure1the connection graph.The connection graph may suggest that we only need to break connections {E, L}, {E, M } and {C, E} in order to remove the Palm Rest.

Table 2 :
Average computation times (sec) of both formulations.The subscripts indicate that number of instances that were solved to optimality for a given setting.

Table 3 :
Objective value gap between both formulations.

Table 4 :
Relative cost differences between LRU Design and C-LRU Design