∎

11institutetext: Chengyan Zhao 22institutetext: Graduate School of Science and
Technology, Nara Institute of Science and Technology, Ikoma, Nara 630-0192,
Japan
22email<EMAIL_ADDRESS>Masaki Ogura
44institutetext: Graduate School of Information Science and Technology, Osaka
University, Suita, Osaka 565-0871, Japan
44email<EMAIL_ADDRESS>55institutetext: Masako Kishida
66institutetext: Principles of Informatics Research Division, National
Institute of Informatics, Tokyo 101-8430, Japan
66email<EMAIL_ADDRESS>77institutetext: Ali Yassine 88institutetext:
Department of Industrial Engineering and Management, American University of
Beirut, Beirut 1107-2020, Lebanon
88email<EMAIL_ADDRESS>
# Optimal Resource Allocation for Dynamic Product Development Process via
Convex Optimization

Chengyan Zhao  Masaki Ogura  Masako Kishida  Ali Yassine

(Received: date / Accepted: date)

###### Abstract

Resource allocation is an essential aspect of successful Product Development
(PD). In this paper, we formulate the dynamic resource allocation problem of
the PD process as a convex optimization problem. Specially, we build and solve
two variants of this problem: the budget-constrained problem and the
performance-constrained problem. We use convex optimization as a framework to
optimally solve large problem instances at a relatively small computational
cost. The solutions to both problems exhibit similar trends regarding resource
allocation decisions and performance evolution. Furthermore, we show that the
product architecture affects resource allocation, which in turn affects the
performance of the PD process. By introducing centrality metrics for measuring
the location of the modules and design rules within the product architecture,
we find that resource allocation decisions correlate to their metrics. These
results provide simple, but powerful, managerial guidelines for efficiently
designing and managing the PD process. Finally, for validating the model and
its results, we introduce and solve two design case studies for a mechanical
manipulator and for an automotive appearance design process.

###### Keywords:

Product development dynamic modelresource allocation investment/performance
trade-offs centrality convex optimization.

##  1 Introduction

Successful Product Development (PD) requires careful allocation of development
resources. Allocating resources to various subsystems and modules within the
product system requires a deep understanding of many complex interactions.
These interactions arise from various sources; namely, due to the physical
interdependencies between the different subsystems in the product itself
(i.e., the product architecture), the arrangements of organizations that will
carry out the development process (i.e., the social network behind the
organization), and the structure of the development process (i.e., predecessor
relationships between development activities) Yassine2019a . In particular,
this paper is focused on obtaining an understanding of the product
architecture and its role in resource allocation decisions during PD111Product
architecture is not the only driver for resource allocation decisions. Other
drivers, such as existing product lineup, competitive products, product demand
and price, technological advancements, consumer taste changes, balancing the
development portfolio, etc., may play an influential role Terwiesch2008 .
However, we focus on product architecture since it is the central issue in our
proposed model..

Product architecture is the scheme by which the functional elements of the
product are arranged into physical chunks and by which the chunks interact
Ulrich1995 . Product architecture plays a significant role in every aspect of
the product lifecycle from influencing how the product is designed,
manufactured, marketed, experienced, serviced, and retired Ulrich2008 ;
Yassine2007 . Additionally, the product architecture has profound implications
for many product behavior properties from robustness Braha2007  to
evolvability Luo2015 . It also influences how resources are allocated in the
PD process Ogura2019 ; Yassine2016 .

Product architecture is usually described by a continuum between an integral
product architecture to a modular one. In integral architectures, the product
functions are shared by product modules (i.e., physical elements), and in
modular architectures, each function is delivered by a separate element or
module. Thus, integrality creates interdependence between product elements or
modules. This interdependency, in turn, results in complexity. That is, some
of the interdependencies may not be known in advance, or their influence on
product and PD process performance may also be unknown. Within this complex PD
environment, several studies have argued that the product architecture may
evolve from integral to modular Christensen2002 ; Yassine2016 .

In this paper, we investigate how the product architecture may influence the
resource allocation decision to various modules using an optimization
framework. Using this framework, we investigate the tendency for product
architectures to evolve form integral to modular architectures. The main
objective of this paper is to check whether the location of a module within
the product architecture can offer PD managers insights into optimal resource
allocation decisions.

Several authors have formulated and analyzed the PD problem by analogy to
dynamic linear systems (e.g., Ogura2019 ; Smith1997 ; Yassine2003 ). In their
analysis, they assumed that all tasks in the design structure matrix (DSM)
proceed in parallel, where the DSM is a matrix representation of the
development network. At any iteration stage, one unit of work on one task
results in a fraction of rework for the other dependent tasks during the next
iteration stage. The dependency between tasks is captured by the numerical
values in the DSM. As such, the work completed in a current design iteration
is a linear function of the work completed in the previous design iteration,
with the linear weights being the numerical values in the DSM.

Other authors have used complexity theory to describe and analyze the PD
process Ahmad2018 . For instance, Braha and Bar-Yam Braha2007  introduced the
NK-based model and analysis of product development project networks. They
showed how the underlying network topologies and statistical structural
properties provide direct information about the functionality, dynamics,
robustness, and fragility of these PD projects. Also, the authors in
Frenken2012  argued that modules could be optimized independently if interface
standards between modules are left unchanged. Similarly, Luo Luo2015  used the
NK framework to show how different product architectural patterns can
influence product evolvability.

Network analysis has also been used for analyzing PD project network
Batallas2006 ; Collins2009 . For example, the analysis of the network
structure (i.e., statistical properties) for various software and hardware
development projects in Braha2007  revealed that these networks have both
small world and scale free network patterns. Additionally, they demonstrated
that complex design networks are highly robust to the failure of randomly
selected design components, but weak for failures targeting specific
components (such as hub components). Similarly, Sosa et al. Sosa2011  found
that the analysis of the network structure of complex product designs
(particularly, the existence of hubs in the design network) impacts the
quality of the product being developed.

More recently, the authors in Yassine2016  have formulated the PD resource
allocation problem as a nonlinear optimization problem. Furthermore, the
authors proposed a dynamic model in which there are several investment runs
(or rounds) during the PD process. This formulation allowed the investigation
of several interesting hypotheses, including the impact of architecture on
performance evolution from integral to modular systems.

In this paper, we offer a more efficient optimization approach based on convex
optimization techniques, which would allow us to find the globally optimal
allocation of development resources222See (Reich2004, , Section 4) for a
related discussion on convex optimization in the context of engineering
design.. In this direction, we first adopt a discrete-time linear system to
represent the work transformation feature in the PD process. Then, we propose
an optimization framework where the resource allocation problem of the PD
process can be transformed into a convex optimization problem. We then apply
our framework to symmetric and synthetic product architectures to reveal the
trends of the evolution of optimal investment. Finally, by analyzing real case
studies with asymmetric PD architectures, we gain insights into the resource
allocation problem and provide a guide for designing and managing the PD
process.

The following sections are organized as follows. In Section 2, we describe the
work transition feature of the PD process by a discrete-time linear system.
Then, we formulate the budget-constrained problem and the performance-
constrained problem for optimal resource allocation. In Section 3, we propose
the framework that both the optimization problems can be transformed into the
convex optimization problems. In Section 4, we perform the experiments and
analysis for the optimal solution of the PD process. Finally, we carry out two
case studies to illustrate the result of this paper in Section 5.

##  2 Proposed model

In this section, we first review the dynamic model of the PD process proposed
in Yassine2016 . Then, from the perspective of system and control, we show
that the work transition feature in the PD process can be expressed by a
discrete-time linear system. Finally, we formulate the optimal resource
allocation problem of the PD process as the budget-constrained optimization
and the performance-constrained problem separately.

###  2.1 Work transformation matrix

In PD, the product architecture is built not only by the constituent parts
that define the product system (i.e., modules or components), but also by the
interaction relationships between these parts (i.e., dependency structure)
Ulrich1995 . In this paper, we assume that the product architecture has been
determined in the early design stage. That is, the modules and their
dependency structure (i.e., design rules) have been established. In this
situation, we focus on improving the performance of PD system through
allocating the development resources to the various modules and design rules
over all investment rounds (i.e., design iterations).

We start the problem formulation by reviewing the dynamic PD model presented
in Yassine2016 . Suppose that there are $n$ modules and $T$ investment rounds
during the PD process, we let $P_{i}(k)$ represent the amount of the remaining
work in the $i$th module after finishing the $k$th investment round. The
remaining work of all modules is defined by the vector

$P(k)=\begin{bmatrix}P_{1}(k)\\\ \vdots\\\ P_{n}(k)\end{bmatrix}.$

The progress of the PD process is evaluated by the sum of the remaining work
in each module Joglekar2001 , which implies that the less total remaining
work, the higher performance the product system has. Thus, the inverse of the
sum of the remaining work from all modules can be adopted as a measurement of
the performance of the PD system at each round, which is expressed by the
following expression:

${1/}\sum_{i=1}^{n}P_{i}(k).$ (1)

At each iteration stage, the module finishes a certain amount of remaining
work, and sends/receives the produced work (i.e., a fraction of rework)
to/from its dependent modules. To describe this work transformation process,
we use a discrete-time linear system expressed by the following equation:

${P(k)=A_{k}(\phi_{k},\gamma_{k})P(k-1),~{}k=1,\dotsc,T,}$ (2)

where $A_{k}(\phi_{k},\gamma_{k})$ is the work transformation matrix (WTM),

$\phi_{k}=\\{\phi_{1,k},\dotsc,\phi_{n,k}\\}$

is the set of the work completion rate of modules, and

$\gamma_{k}=\\{\gamma_{ij,k}\\}\quad(i,j=1,\dotsc,n,\ i\neq j)$

is the set of the updated value of design rules. The value of the inter-module
variable $\gamma_{ij,k}$ represents the work flow strength from module $i$ to
$j$ at $k$th investment round, i.e., at round $k+1$, the accumulated produced
work to module $j$ is the sum of the multiplication of the remaining work
$P_{i}(k)$ on module $i$ and $\gamma_{ij,k}$. For an established product
architecture, the performance of the product system can be further improved by
investing in both modules (i.e., determining the work completion rate in each
iteration stage) and design rules (i.e., reducing the dependency strength
between two modules). We assume that $\phi_{k},\gamma_{k}$ can be tuned within
the following intervals:

$0<\underaccent{\bar}{\phi}_{i,k}\leq\phi_{i,k}\leq\bar{\phi}_{i,k},\quad
0<\underaccent{\bar}{\gamma}_{ij,k}\leq\gamma_{ij,k}\leq\bar{\gamma}_{ij,k},$

where $\bar{\phi}_{i,k},\bar{\gamma}_{ij,k}$ are the initialized parameter
values in (2), and
$\underaccent{\bar}{\phi}_{i,k},\underaccent{\bar}{\gamma}_{ij,k}$ are the
upper and lower bounds of the parameters, respectively. For the PD process
with multiple investment rounds, the authors in Yassine2016  showed that
unlike the memoryless feature in the investment for the modules, the
investment in the design rules for reducing the work flow strength has a
cumulative effect. That is, $\gamma_{ij,k}$ at the $k$th round is updated to
include the values of the design rules that resulted from the investment prior
to the $k$th round. Therefore, the updated values of the design rules at the
$k$th iteration $\gamma_{ij,k}$ is the multiplication of the updated value of
the design rules from the $1$st to the $k$th round, which is expressed as
$\prod_{\ell=1}^{k}\gamma_{ij,\ell}$. The specific form of the matrix
$A_{k}(\phi_{k},\gamma_{k})$ is given by

$A_{k}(\phi_{k},\gamma_{k})=\begin{bmatrix}\phi_{1,k}&\prod_{\ell=1}^{k}\gamma_{12,\ell}&\cdots&\prod_{\ell=1}^{k}\gamma_{1n,\ell}\\\
\prod_{\ell=1}^{k}\gamma_{21,\ell}&\phi_{2,k}&\cdots&\prod_{\ell=1}^{k}\gamma_{2n,\ell}\\\
\vdots&\vdots&\ddots&\vdots\\\
\prod_{\ell=1}^{k}\gamma_{n1,\ell}&\prod_{\ell=1}^{k}\gamma_{n2,\ell}&\cdots&\phi_{n,k}\end{bmatrix}.$

Suppose that we can use the development resources to update the value of
$\phi_{k},\gamma_{k}$. That is, we can use the resources to tune the work
completion rate $\phi_{k}$ and the dependency strength $\gamma_{k}$. Moreover,
we assume that there is an associated cost $f_{i}(\phi_{i,k})$ for tuning the
value from $\bar{\phi}_{i,k}$ to $\phi_{i,k}$. Likewise,
$g_{ij}(\gamma_{ij,k})$ is the cost for tuning the value $\bar{\gamma}_{ij,k}$
to $\gamma_{ij,k}$. Then, the total cost at the $k$th investment round equals

$B_{k}(\phi_{k},\gamma_{k})=\sum_{i=1}^{n}f_{i}(\phi_{i,k})+\sum_{i=1}^{n}\sum_{i\neq
j}g_{ij}(\gamma_{ij,k}).$ (3)

Form the perspective of the project manager, it is imperative to optimally
allocate the development resources to obtain the maximum benefit, especially
when a huge project is carried out. However, making the optimal resource
allocation strategy for thousands of decision variables just by experience and
intuition seems not very effective. Thus, a mathematical programming
formulation for finding the optimal investment strategy is essential.

###  2.2 Optimization problem

As mentioned in Section 2.1, at each iteration, PD managers can use a certain
amount of development resources to improve the performance of the product
system. Particularly, the resources can be allocated on a module for tuning
its work completion rate or on the design rule for reducing the dependency
strength between two modules. Assuming that given a set of budgets for each
investment round during the whole development process, how should we make the
allocation strategy to minimize the total remaining work of the PD process?
Based on this question, we formulate the budget-constrained problem as
follows:

######  Problem 1 (Budget-constrained optimization)

Assume
that, given $P(0)$, there are $T$ investment rounds with the corresponding
budgets $\bar{B}_{k}>0$ ($k=1,\dotsc,T$) for resource allocation during the PD
process, as well as the cost functions $f_{i}(\phi_{i,k})$ and
$g_{ij}(\gamma_{ij,k})$. Find a sequence of decision variables for allocating
the resources in modules $\phi=\\{\phi_{i,k}\\}_{k=1}^{T}$ $(i=1,\dotsc,n)$
and design rules $\gamma=\\{\gamma_{ij,k}\\}_{k=1}^{T}(i,j=1,\dotsc,n,\ \
i\neq j)$ to maximize the performance measure (1).

Mathematically, we formulate the budget-constrained
problem as:

$\displaystyle{\operatorname*{\ \ \ \text{maximize}\ \ \ }_{\phi,\gamma}}$
$\displaystyle{1/}\sum_{i=1}^{n}P_{i}(T)$ (4a) $\displaystyle\operatorname*{\
\ \ \text{subject to}\ \ \ }$ $\displaystyle
B_{k}(\phi_{k},\gamma_{k})\leq\bar{B}_{k},$ (4b)
$\displaystyle{0<\underaccent{\bar}{\phi}_{i,k}\leq\phi_{i,k}\leq\bar{\phi}_{i,k},}$
(4c)
$\displaystyle{0<\underaccent{\bar}{\gamma}_{ij,k}\leq\gamma_{ij,k}\leq\bar{\gamma}_{ij,k},}~{}{k=1,\dotsc,T.}$
(4d)

For the budget-constrained problem, our goal is to make the optimal resource
allocation strategy to maximize the PD performance. However, PD managers also
face another challenge when the manager plans to meet prescribed target on the
remaining work at $T$. The question becomes: how to make the resource
allocation decision to minimize the cost of meeting the prescribed performance
requirement? In this case, we formulate the performance-constrained problem as
follows:

######  Problem 2 (Performance-constrained optimization)

Assume that, given $P(0)$, there are $T$ investment rounds and the prescribed
performance requirement $\underaccent{\bar}{\pi}>0$, as well as the cost
functions $f_{i}(\phi_{i,k})$ and $g_{ij}(\gamma_{ij,k})$. Find a sequence of
decision variables for allocating the development resources in modules
$\phi=\\{\phi_{i,k}\\}_{k=1}^{T}$ $(i=1,\dotsc,n)$ and design rules
$\gamma=\\{\gamma_{ij,k}\\}_{k=1}^{T}~{}(i,j=1,\dots,n,~{}i\neq j)$ to
minimize the total investment while satisfying the requirement on the
performance (1).

As in (4), we can mathematically build the performance-constrained problem as
the following:

$\displaystyle\operatorname*{\ \ \ \text{minimize}\ \ \ }_{\phi,\gamma}$
$\displaystyle\sum_{k=1}^{T}B_{k}(\phi_{k},\gamma_{k})$ (5a)
$\displaystyle\operatorname*{\ \ \ \text{subject to}\ \ \ }$
$\displaystyle{1/}\sum_{i=1}^{n}P_{i}(T){\geq\underaccent{\bar}{\pi}},$ (5b)
$\displaystyle{0<\underaccent{\bar}{\phi}_{i,k}\leq\phi_{i,k}\leq\bar{\phi}_{i,k},}$
(5c)
$\displaystyle{0<\underaccent{\bar}{\gamma}_{ij,k}\leq\gamma_{ij,k}\leq\bar{\gamma}_{ij,k}.}~{}{k=1,\dotsc,T.}$
(5d)

Notice that the performance constraint (5b) is equivalent to the following
constraint on the sum of the remaining work:

$\sum_{i=1}^{n}P_{i}(T)\leq\bar{P},$

where

$\bar{P}=1/\underaccent{\bar}{\pi}$

is regarded as the maximum allowable amount of the remaining work left at the
end of the investment.

The difficulty of solving the budget-constrained problem and the performance-
constrained problem mainly stems from the nonlinearity of the functions (4a),
(5a) and constraints (4b), (5b). That is, the budget-constrained problem and
the performance-constrained problem become nonlinear optimization problems.
Although there are some numerical solutions for this case based on heuristic
methods Alcaraz2003a ; Boctor1996 , such techniques can cause the solution to
be trapped in a local optimal point. Moreover, the computation cost of the
heuristic solver grows rapidly with the increase in problem size (i.e., the
number of modules, design rules and the investment rounds). Thus, there exists
a need for developing a computation framework that can deliver the optimal
solution for a relatively large size of the resource allocation problem.

Figure 1: Four DSM architectures. All with $50$ modules and $100$ design
rules: (a) block-diagonal network, (b) Erdős-Rényi network (Random), (c) Watz-
Strogatz network (Small world), (d) Barabási-Albert network (Scale free). The
diagonals in the DSM represent the location of modules, and the off-diagonals
show the dependencies between modules.

##  3 Solution using convex optimization

In this section, we present an optimization framework for efficiently solving
the budget-constrained problem and the performance-constrained problem. Under
the relatively mild assumption on the cost function, we can show that problems
can be transformed into convex optimization problems. Let us begin with
reviewing the definition of posynomials with the following:

######  Definition 1 (Boyd2004 )

Let $v=\\{v_{1}$, $\dotsc$, $v_{n}$} denote $n$ real positive variables.

  1. 1.

We say that a real function $g(v)$ is a monomial if there exist $c>0$ and a
set of real numbers $a_{1},\dotsc,a_{n}$ such that $g(v)=cv_{\mathstrut
1}^{a_{1}}\dotsm v_{\mathstrut n}^{a_{n}}$.

  2. 2.

We say that a real function $f(v)$ is a posynomial if $f$ is a sum of
monomials of $v$.

To precisely model the cost features, the nonlinearity from the practical
problem can not be ignored. From Definition 1, we can see that the posynomials
are nonlinear functions which can be used for fitting real data from practical
PD problems. For specific techniques to fit posynomials to real data, we refer
readers to Boyd2007a . Also, the following lemma shows the convexity property
of posynomials, which is essential in transforming the budget- and
performance-constrained problems into convex optimization problems.

######  Lemma 1 (Boyd2007a )

If $f$ is a posynomial, then, the function $x\mapsto\log f(\textup{exp}[x])$
is convex.

As mentioned earlier, the nonlinearity of the real data can be fitted by
posynomials. From Definition 1, we can see that the range of the posynomials
is in the nonnegative number field. However, in practice, real data may run
out of the nonnegative area. Thus, normalizing the range of the cost function
to the nonnegative field is necessary (i.e., adjust the minimum value of the
cost function larger than $0$). For ensuring the non-negativity of the cost
function, we assume a specific structure Ogura2020  on the cost function:

$\displaystyle f_{i}(\phi_{i,k})$
$\displaystyle=f_{i}^{+}(\phi_{i,k})-f_{i}^{+}(\bar{\phi}_{i,k}),$
$\displaystyle g_{ij}(\gamma_{ij,k})$
$\displaystyle=g_{ij}^{+}(\gamma_{ij,k})-g_{ij}^{+}(\bar{\gamma}_{ij,k}).$

The essential part of the cost function is the first term
$f_{i}^{+}(\phi_{i,k})$, while the second term
$(-f_{i}^{+}(\bar{\phi}_{i,k}))$ is for normalizing the cost function as
$f_{i}(\bar{\phi}_{i,k})=0$, similarly for $g_{ij}(\gamma_{ij,k})$, which
means that the zero investment yields no cost.

The resulting optimization problems (4) and (5) are not trivial to solve
directly because the nonlinearity in the work transformation process function
(4a), (5b) and the resource cost functions (4b), (5a). Although there exist
heuristic optimization methods that can solve this problem, the solution is
local optimal due to the constraint of the algorithm. In a complex product
development project that contains hundreds of modules and design rules,
finding the global optimal resource allocation strategy can bring great
benefit for the company and shareholders. Therefore, it is necessary to
establish an efficient computation framework for obtaining the global optimal
solution to the problems (4) and (5).

The following theorem allows us to overcome the difficulty and solve the
budget-constrained problem and the performance-constrained problem via convex
optimization and is the main theoretical result of this paper. The proof of
the theorem is presented in the Appendix.

###### Theorem 3.1

Problems 1 and 2 reduce to convex optimization problems.

Figure 2: Three cost functions with $p$ = 1, 10, and 50.
$f_{ij}(\Omega_{ij})=0$ represents that no resource is allocated, where
$\Omega_{ij}$ denotes the initial value of the certain entry in WTM.
$f_{ij}(\epsilon\Omega_{ij})=1$ indicates the upper bound of the allocated
resources where we can to obtain the fully improved value.

##  4 Experimental setup, analysis and discussion of results

In this section, we show the effectiveness of the proposed framework by
solving relatively large-size PD problems with different product
architectures. Furthermore, by investigating the solution, we reveal the
trends, structure, and relationship of the decision variables. In Section 4.1,
we introduce four typical DSM architectures embedded in our simulation
experiments. In Section 4.2, we give the specific form of the cost function.
Then, in Section 4.3, we present the optimal solution of the budget-
constrained problem, perform its analysis, and discuss the results. Likewise,
in Section 4.4, the optimal solution of the performance-constrained problem is
demonstrated and discussed. In Section 4.5, we statistically investigate the
impact of product architecture on optimal resource allocation.

###  4.1 DSM architecture

As mentioned earlier, the design structure matrix (DSM) is a matrix
representation of the development network having a particular architecture
Jan2007 . For this reason, the DSM architecture in our experiment is
determined by the following network models: the block-diagonal Jan2007 , the
Erdős-Rényi (random) erdos59a , the Watz-Strogatz (small world) Watts1998a
and the Barabási-Albert (scale free) Barabasi1999  graphs.

Fig. 1 shows the four DSM architectures used in this paper. On one end, the
block-diagonal network represents a typical modular architecture, where the
dependencies between modules are divided into dependent groups (no
interactions between the groups), and the modules in each group are fully
dependent (see Fig. 1 (a) Yu2007 ). Alternatively, the Watz-Strogatz network
and the Barabási-Albert network represent the other extreme, called integral
architecture. The Watz-Strogatz network in Fig. 1 (c) shows the small world
property, where most modules dependencies are local, but few dependencies
exist between the distant modules Watts1998a ; Yassine2016 . The Barabási-
Albert network in Fig. 1 (d) illustrates the preferential attachment feature
of the PD project. The project starts with few modules and as the design
process unravels the new modules are linked to the old modules Barabasi1999 ;
Yassine2016 . We adopt the Erdős-Rényi network in Fig. 1 (b) for randomly
setting the dependency structure in the DSM, which serves as a benchmark to
other patterned DSM architectures. For other DSM architectures, we refer the
readers to Braha2004 ; Braha2004a ; Yassine2016 .

###  4.2 Cost function

As mentioned in Section 2.1, the resources allocated on the modules and design
rules result in a reduction of the parameters in (2). Based on this, we claim
that the cost function should be a decreasing function, and satisfy Definition
1. Thus, we use the following cost function:

$f_{ij{,k}}(\gamma_{ij{,k}})=c_{ij}\left(\frac{1}{(\gamma_{ij{,k}})^{p}}-\frac{1}{(\Omega_{ij{,k}})^{p}}\right),$
(6)

where $\gamma_{ij,k}$ ($i,j=1,\dots,n,~{}i\neq j$) is the updated value of the
parameter in the WTM, $p$ is a positive real number for tuning the shape of
the concerned cost function, and $c_{ij}$, $\Omega_{ij}$ are positive numbers
for fitting the value of the cost function to satisfy Definition 1. Then, we
make the following assumption to show the diminishing return property, which
ensures the convexity of the cost function as well. Suppose that there is a
fixed increment $\epsilon_{ij}>0$ on $\gamma_{ij}$, and let $\Delta
f_{ij}(\gamma_{ij})=f_{ij}(\gamma_{ij}-\epsilon_{ij})-f_{ij}(\gamma_{ij})$
represent the cost for tuning $\gamma_{ij}$ to $\gamma_{ij}-\epsilon_{ij}$.
The diminishing return property means that the parameter tuning cost $\Delta
f_{ij}(\gamma_{ij})$ increases with $\gamma_{ij}$, and also implies the
convexity of $f_{ij}$. In practice, the parameters of the cost function are
carefully assigned by the managers and the work teams (e.g., see Stellman2005
; Yassine2016 ). Fig. 2 shows three realizations of the cost function under
different values of $p$.

###  4.3 Analysis and discussion of the budget-constrained problem

Figure 3: The optimal solution of the budget-constrained problem. Color lines
distinguish the importance of modules/design rules via the PageRank (the
importance is fixed from $0$ to $1$, see the colorbar on the right side).

In this subsection, we optimally solve the budget-constrained problem through
our proposed framework. Then, we investigate the evolution of decision
variables during the budget-constrained PD process. Finally, we introduce the
centrality metrics for measuring the importance of modules and design rules,
and study whether the allocated resources or the remaining work in each module
or design rule correlates with its centrality.

In this simulation experiment, for testing the effectiveness of solving a
relatively large scale PD problem Baldwin2000 , we produce the DSMs of size
$50$ and hold the total number of dependencies to $100$ for each DSM
architecture. We set the number of investment rounds $T=5$, and the budget
$\bar{B}_{k}=300$ for each investment round. For initializing the parameters
of the WTM, we unify $\bar{\phi}_{i,k}=0.5$ $(k=1,\dotsc,5,i=1,\dotsc,50)$ and
$\bar{\gamma}_{ij,k}=0.05$ $(i,j=1,\dotsc,50,i\neq j)$ for all the
experiments. For all the cost functions, we unify the parameters with
$c_{ij}=1$, $p=1$, $\Omega_{ij}=1$, and $\epsilon=0.1$, which indicates that
the $\phi$ and $\gamma$ can be updated between $[0$$\%-90$$\%]$ of the initial
value. From the parameter initialization, we can see that the values of
$\phi_{i,k}$ and $\gamma_{ij,k}$ can be tuned within the intervals
$[0.05,0.5]$ and $[0.005,0.05]$, respectively. We conduct the experiments with
the selected DSM architectures in Fig 1, and observe the following response
variables: the remaining work in modules, the investment in the modules and
the design rules, and the dependency strength between modules.

For problem solving, we adopt the commonly used off-the-shelve software for
convex optimization problem: fmincon routine in MATLAB. From the experiment
setup, we can see that the total number of the decision variables is
$(50+100)\times 5=750$, which reaches the standard size of large PD process.
Through running the experiment on the desktop with common configuration (i.e.,
Intel Core i7-7700 and 8GB memory), the average time for solving the
optimization problem is $210$ minutes, which illustrates that our framework is
capable for solving the much larger-scale problems.

Figure 4: Evolution of the completion rate in the budget-constrained problem.
Figure 5: The correlation between the investment in module and the total
investment in its dependent design rules in the optimal solution of the
budget-constrained problem.

Figure 6: The remaining work, investment in modules and design rules of
Problem 1 versus their centrality measures in the Erdős-Rényi (random)
network. Dash line: Linear regression line.

Figure 7: The remaining work, investment in modules and design rules of
Problem 1 versus their centrality measures in the Watz-Strogatz (small world)
network. Dash line: Linear regression line.

Figure 8: The remaining work, investment in modules and design rules of
Problem 1 versus theirr centrality measures in the Barabási-Albert (scale-
free) network. Dash line: Linear regression line.

Figure 9: The remaining work, investment in modules and design rules of
Problem 1 versus their centrality measures in the Block-diagonal network. Dash
line: Linear regression line.

Fig. 3 shows the evolution of the resource allocation variables ($\phi_{i,k}$,
$\gamma_{ji,k}$), the remaining work $P_{i}(k)$ and the dependency strength of
design rules in solving the budget-constrained problem. Particularly, Fig. 3
(a) shows the decreasing trends of the remaining work in each module, which
indicates that the PD process is in progress. However, this experiment
contains more than $1$ investment round, so just by observing the remaining
work from Fig. 3 (a) is not easy to distinguish the effect of the investment
at each round. Thus, we define the completion rate $\xi(k)$ for each
investment round by

$\xi(k)=\frac{\sum_{i=1}^{n}P_{i}(k)-\sum_{i=1}^{n}P_{i}(k+1)}{\sum_{i=1}^{n}P_{i}(k)}.$

From Fig. 4, we can observe the evolution of the completion rate during the
process, where the performance of product system is monotonically improved
with successive investment. Compared with the experiment with no investment
(dashed line), we can derive that the PD process is accelerated with the
allocated resources. As seen in Fig. 4, with the investment in progress, the
performance reaches its saturation. We also notice that the limits of
performance are different for the DSM architectures, which implies that the
DSM architecture must be taken into consideration for further studying the
performance. We note that the high performance of the block-diagonal network
is consistent with the finding in Braha2004  that real design networks have a
nested hierarchical network structure.

Figs. 3 (b) and 3 (c) show the evolution of investment in modules and design
rules, where we can see that the investment in modules increases, while the
investment in design rules decreases. This phenomenon is in line with the
result in Yassine2016  that there is a shift in resource allocation from
design rules to modules as the development process progresses. Moreover, it is
worth noting that the modular architecture consumed more resources on the
modules compared with design rules, while integral architecture consumed more
resources on the design rules. Thus, the evolution of the decision variables
also confirms that the product architecture evolves from integral to modular
as the product matures. In Fig. 3 (d), we can see that the dependency values
of the design rules tends to $0$, which indicates that the dependency strength
between modules is reduced or nearly eliminated by successive investment in
design rules.

Next, we carry out a further investigation on whether there is a relationship
between the optimal cumulative investment in a specific module and its related
design rules. We define the cumulative allocated resources on the module
during the process by

$\mu_{i}=\sum_{k=1}^{T}f_{i}(\phi_{i,k})$

and its related design rules

$\rho_{i}=\sum_{k=1}^{T}\left(\sum_{j=1}^{n}g_{ij}(\gamma_{ij,k})+\sum_{j=1}^{n}g_{ji}(\gamma_{ji,k})\right).$

We also define the cumulative allocated resources on design rules by

${\rho_{ij}=\sum_{k=1}^{T}\left(g_{ij}(\gamma_{ij,k})+g_{ji}(\gamma_{ji,k})\right).}$

Fig. 5 shows a positive correlation between the investment in the modules and
its related design rules. This observation can be used as a managerial
guideline for resource allocation: if a module is assigned with a certain
amount of resources, then corresponding amount of resources must be allocated
to its related design rules.

Table 1: Pearson correlation analysis for the budget-constrained problem
(Figs. 7-9)

After discussing the results in Fig. 3, we introduce the centrality metrics
(i.e., importance measures) for the modules and design rules to investigate
whether there is a relationship between the investment in module/design rule
and its centrality. For describing the importance of the modules and design
rules, we adopt three centrality metrics Newman2010 : the Eigenvector, the
PageRank, and the Closeness centrality. For simplicity, we normalize each
centrality metric to $1$. Throughout the paper, we let the centrality metric
of the $i$th module be denoted by $r_{i}$, and the centrality metric of a
design rule between the $i$th and the $j$th module be denoted by $r_{ij}$,
respectively. Then, Figs. 7-9 show the the dependence on the centrality
measures of remaining work $P_{i}(T)$, cumulative resource allocation
$\mu_{i}$ on the modules, and cumulative resource allocation $\rho_{ij}$ on
the design rules. From Figs. 7-9, we observe that the extent of correlation
varies with different centrality metrics. To decide which centrality metric
performs the best in describing the correlation, we adopt Pearson correlation
Benesty2009  to help us select the proper centrality metric. A perfect Pearson
correlation $1$ occurs when each of the variables is a perfect monotone
function of the other. On the contrary, $0$ means that there is completely no
correlation between the two set of numbers. Table 1 shows the result of
Pearson correlation for Figs. 7-9. From Table 1, we can see that PageRank
performs the best except for the block-diagonal case because the definition of
PageRank is infeasible for measuring the block-diagonal network. Fortunately,
both the Eigenvector centrality and the Closeness centrality perform a strong
linear correlation, which can be used for the block-diagonal case.

From Figs. 7-9, we find that there exists a relatively strong correlation
between the investment/remaining work and its PageRank centrality under the
four DSM architectures. So, as a quick heuristic, we can assign the budget as
a function of centrality instead of solving a complex optimization problem, as
previously found in Braha2007 ; Maier2014 . Moreover, PD managers can use
PageRank centrality as a proxy to allocate development resources for the
modules.

Figure 10: The optimal solution of the performance-constrained problem. Color
lines distinguish the importance of module/design rules via the PageRank.

For the correlation between the investment in the design rule and its
centrality in Figs. 7 (c)-9 (c), we can see that the extent of correlation in
Figs. 7 (c)-9 (c) is not strong enough for drawing a conclusion. However, for
the block-diagonal case in Fig. 9 (c), we observe a different phenomenon that
hundred of variables are overlapped to a few points, and are strongly
correlated with the Eigenvector and the Closeness centrality. Specifically, we
notice that design rules belonging to different sub-blocks but with the same
size receive the same amount of investment. In other words, the investment in
design rules is independent of the block to which it belongs. This
independence is caused by the special structure of the block-diagonal network,
in which all the sub-blocks are independent of each other.

###  4.4 Analysis and discussion of the performance-constrained problem

In this subsection, we solve the performance-constrained problem via convex
optimization. Although we have revealed the trends of the decision variables
and the internal relations for the budget-constrained problem, we cannot
conclude that the same situation also exists in the performance-constrained
problem.

As in Section 4.3, we perform the simulation experiment on a controlled set of
product architectures. For initializing the performance-constrained problem,
we adopt the same parameters setting as the budget-constrained problem. Based
on the formulation of the performance-constrained problem, we set the
constraint for the total remaining work of the final investment round to
$\bar{P}=0.01$, which can be regarded as a threshold for judging the
accomplishment of the PD process. For example, suppose that the total
remaining work at the beginning is normalized to $1$, if we set
$\bar{P}=0.01$, it means that when the total remaining work is $1\%$ its
initial value, we can say that the project is finished. We conduct the
experiments with the selected DSM architectures in Fig 1, and observe the
following response variables: the remaining work in modules, the investment in
the modules and the design rules, the dependency strength between modules, and
the total investment at each round.

Fig. 10 shows the evolution of decision variables and the remaining work of
the performance-constrained problem. From Figs. 10 (a)-(c), we can see that
the solution of the performance-constrained problem exhibits similar trends to
the budget-constrained problem. Particularly, the solution shows that the
product architecture evolves from an integral to a modular as successive
investment are made on the modules and the design rules. In Fig. 10 (d), it is
worth noting that there is a decreasing tendency on the total investment
during the PD process, which contradicts our intuition that the resources
should be equally allocated for each investment round. In the performance-
constrained problem, we also find the positive correlation between the
investment in the module and its related design rules as the budget-
constrained problem. Further analysis similar to the ones for the performance-
constrained problem allows us to draw the same set of conclusions as the one
we obtained for the budget-constrained problem. The details are omitted.

Figure 11: The total investment and performance of the budget-constrained
problem versus different DSM architectures. The difference among the networks
is statistically significant at the significance level of 10%, except between
the random and small world networks. Figure 12: The total investment and
performance of performance-constrained problem versus different DSM
architectures. The difference among the networks is statistically significant
at the significance level of 10%, except between the random and small world
networks.

###  4.5 Analysis of different DSM architectures

In this subsection, we carry out an analysis of variance on the product
architecture to investigate whether the product architecture affects the
resource allocation and the performance of the designed PD system. It is
important to remark that the set of synthetic networks we use for our analysis
is not intended to replicate all the aspects of real design networks,
specifically the significant difference between the distribution of in- and
out-degrees in the product architecture Braha2004 ; Braha2004a ; Braha2007 .

In this experiment, we used the four DSM architectures introduced in Fig. 1
and selected the three response variables: total remaining work, total
investment in modules, and total investment in design rules. To detect any
statistical difference, we randomly generate $50$ sample networks for each
type of product architecture. In all the problems, we unify the parameters of
the WTM and the cost functions as in the previous sections. We solve these
problems with the proposed framework in this paper. The results of the budget-
constrained problem and the performance-constrained problem sorted by product
architecture are shown in Figs. 11 and 12, respectively. We use Boxplots to
illustrate the maximum, the minimum, the variance, and the mean value of the
investment and the remaining work. We observe that the architecture affects
the resource allocation, which in turn affects the remaining work, investment
in modules and design rules of the PD process. To statistically investigate
the dependence, we also carry out one-way ANOVA tests Tabachnick2007  between
pairs of data. We adopt the $p$-value from the ANOVA test as an index to
illustrate the difference between each two networks. We observe that the
difference among the networks is statistically significant at the significance
level of 10%, except between the random and small world networks. This
tendency could be partly attributed to the similarity in the construction
rules for these two networks.

For the remaining work of the budget-constrained problem (Fig. 11 (a)), we can
see that the block-diagonal architecture has the minimum remaining work (the
best performance) compared with the other three architectures, which indicates
that the modular architecture performs better than integral architecture
(i.e., small world and scale free). Besides, we also notice that although the
block-diagonal has the best performance, the variability is larger than the
Small world case. This result implies that the stability of product
architecture can not be neglected in designing the DSM structure. From Figs.
11 (c) and (e), we confirm that there exists a variance on the investment in
modules and design rules with different product architectures. Also, from Fig.
12 for the performance-constrained problem, we can see that for meeting the
same target of the remaining work, the block-diagonal architecture costs the
minimum resources among the four architectures, which also indicates that the
modular architecture performs better than integral architecture.

Table 2: Task duration of tire and wheel manipulator design

Table 3: The WTM of the manipulator design process

Table 4: WTM for Automotive appearance design

###  4.6 Limitation and robustness

We discuss the limitation and robustness of our analysis in this section.
First, as we remarked in the introduction, the set of synthetic networks we
use for our analysis does not necessarily cover all the types of realistic
design networks. As revealed in the seminal works in Braha2004 ; Braha2004a ;
Braha2007 , empirical product development architectures often exhibit
distinctive asymmetry between the distributions of incoming and outgoing
links. For this reason, we investigate real product development processes
having asymmetric architectures in the next section.

Second, our findings above are dependent on the the current choice of relevant
parameters. In order to examine the robustness of our analysis to the choice
of parameters, we let the shape parameter $p$ of the cost function (6) vary
between $[1,10]$ and perform simulations. We then found that the solution
(i.e., the resulting pattern of resource allocation) exhibits the same trend,
which suggests the robustness of our analysis. We also vary the other shape
parameter $c_{ij}$ to find that, the larger $c_{ij}$, the lower the effect of
the investment on the development process due to the higher price of the
resources.

##  5 Case study

In this section, we demonstrate and validate our proposed model using two case
studies considering the resource allocation problems for the PD processes
presented in George2012 ; Yassine2003 .

Figure 13: Optimal investment in modules and design rules of the budget-
constrained problem versus PageRank centrality in the tire and wheel
manipulator design. (a) Remaining work versus centrality; (b) investment in
modules versus centrality; (c) investment in design rules versus centrality;
(d) investment in module versus the total investment in its dependent design
rules. Figure 14: The optimal solution of the budget-constrained problem of
case study $1$. Color lines distinguish the importance of module/design rules
via the PageRank. (a) Investment in modules versus centrality. (b) Investment
in design rules versus centrality.

###  5.1 Case 1: Mechanical manipulator design

In this section, we consider the case study problem of the tire and wheel
manipulator design process presented in George2012 . Table 4 lists all the
tasks for the design process and the best/worst duration for each task (in
hours) per investment round. The dependency structure of the design process,
illustrating the interactions among the tasks, is demonstrated in the DSM (or
WTM) as shown in Table 4. In Table 4, the diagonal entries represent the
completion rate for handling the remaining work of the task, while the off-
diagonal element indicates the ratio of the fractional work exchanged among
the tasks. In this paper, we adopt the inverse of average duration as the
value of the diagonal entries of WTM. Table 4 shows the value of dependency
strength between the tasks which are assigned in three numerical values: 0.5,
0,25 and 0.05 for strong (S), medium (M), and weak (W) dependencies,
respectively.

The assessment of the various input parameters to our model can be easily
collected through a set of structured interviews (perhaps using a survey
instrument) following a similar procedure to the one described in Yassine2016
. For the assessment of the various DSM parameters used in our analysis, we
recommend a three-step procedure: Kick-off, individual estimation, and
review/wrap-up. In the first step, a one-hour kick-off meeting is conducted
with the product development project team to identify all the development
tasks. In the second step, short individual interviews are conducted with each
team member to solicit their estimate for task durations using two- or three-
point estimates for most-likely duration, worst case duration, and most
optimistic (best) duration. Also, in this step, interviewees are asked about
their dependencies on other tasks from the already established list of tasks.
A simple subjective scale can be used for the strength of the identified
dependencies: strong, medium and weak. In the final step, the product
development project team is assembled again to review the results of the
interviews and resolve any discrepancy or disagreement in any of the
estimates.

In our case study, we specify the manipulator design problem with an initial
work vector $P(0)={[1,\,\dotsc,\,1]^{\top}}$ (i.e., all the tasks at the
beginning of the design process have $100$$\%$ work remaining). We adopt the
mean value of the best and worst duration as a measure of the complexity of
each task (i.e.,
$A_{1}(\bar{\phi}_{1},\bar{\gamma}_{1})_{i}=(t_{\max{}}^{i}+t_{\min{}}^{i})/2$)
the initial value of the diagonal entries in WTM). While the values of the
dependency strength between tasks are represented by the off-diagonal entries
of WTM. For the cost function, we unify the parameters of all cost functions
with $c_{ij}=1$, $p=1$, $\Omega_{ij}=1$, in that case, the unit of investment
in the individuals has the same effect. Also, we let the variable $\phi$ and
$\gamma$ of cost function vary within the interval $[0.1,1]$, which means
that, after each investment round, the rate of dealing process in each module
and design rule can be accelerated between $[0$$\%-90$$\%]$. Also, we set
investment round $T=5$ for the PD process. In the budget-constrained problem,
we let the investment budget for each round equally fixed by
$\bar{B}_{k}=200~{}(k=1,\dotsc,T)$. For the performance-constrained problem,
we set the target for the remaining work $\sum_{i=1}^{n}P_{i}(T)=0.01$, which
means that if the remaining work exceeds the threshold $1$$\%$, we can assume
the completion of the PD process. From Section 4, we have shown the trends and
structure of the optimal solution, so in the case study, we only focus on
analyzing the relations between the importance of modules and design rules
(i.e., their centrality) in the WTM network and their allocated
investment/performance.

Figure 15: Optimal investment in modules and design rules of the budget-
constrained problem versus PageRank centrality in the automotive appearance
design. (a) Remaining work versus centrality; (b) investment in module versus
centrality; (c) investment in design rules versus centrality; (d) investment
in module versus the total investment in its dependent design rules. Figure
16: The optimal solution of case study $2$. Color lines distinguish the
importance of module/design rules via the PageRank. (a) Investment in modules
versus centrality. (b) Investment in design rules versus centrality.

Based on the analysis result from Section 4, we adopt the PageRank centrality
for measuring the importance of the task/dependency in the WTM network. From
Fig. 13, we can see that both problems reveal the same trends and structure.
In Fig. 13 (a), the regression line shows that there is a correlation but not
strong between the remaining work in the module and its PageRank centrality.
We can still conclude that the task with higher centrality tends to have a
larger amount of remaining work. In Fig. 13 (b), we get nearly the same trend
that the task with higher centrality tends to receive larger investment.
However, in Fig. 13 (c), there is still an ambiguous correlation between the
investment in dependency and its corresponding centrality, which coincides
with the analysis result in Section 4. From Fig. 13 (d), we can see there is a
clear positive correlation between the investment in the task and the total
investment in its dependencies. In Fig. 14, we present the evolution of
investment in modules and design rules. We can confirm the increasing trend in
modules and decreasing trend in design rules, as we have found in our
synthetic analysis in Section 4.

###  5.2 Case 2: Automotive appearance design

In this section, we adopt the automotive appearance design presented in
Yassine2003 , which focuses on the design process of the interior and the
exterior surface of the automotive for achieving a balance among the
appearance, quality, and operational interface. However, we only focus on the
local team which contains the following tasks: 1) carpet, 2) center console,
3) door trim panel, 4) garnish trim, 5) overhead system, 6) instrument panel,
7) luggage trim, 8) package tray, 9) seats, and 10) steering wheel.

The WTM for the appearance design is given in Table 4 where the diagonal
entries represent the completion rate on each module, while the off-diagonal
entries represent the ratio of the rework exchanged between each task. In this
case study, we specify the automotive appearance design problem with an
initial work vector $P(0)={[1,\,\dotsc,\,1]^{\top}}$. For the cost function,
we unify the parameters of all cost functions with $c_{ij}=1$, $p=1$,
$\Omega_{ij}=1$, in that case, the unit of investment in the individuals has
the same effect. Also, we let the variable $\phi$ and $\gamma$ of cost
function vary within the interval $[0.1,1]$, which means that, after each
investment round, the the completion rate on each module and design rule can
be accelerated between $[0$$\%-90$$\%]$.

We use 5 investment rounds $(T=5)$ for the design process. In the budget-
constraint problem, we let the amount of investment at each round equally
fixed to $\bar{B}_{k}=200$. For the performance-constraint problem, we set the
target for the remaining work $0.01$, which means that if percentage of the
remaining work is $1$$\%$ of its initial value, then this will indicate the
completion of the PD process. As in the previous case study, we focus on
analyzing the relations between the importance of modules and design rules in
the WTM and their allocated investment/performance.

Fig. 15 shows the investment versus the PageRank centrality measures. For the
relationship between the performance/remaining work of the module and its
importance, we can see from Fig. 15 (a) that the module with a higher
centrality has a larger amount of remaining work. This result coincides with
our intuition that the module has a lower centrality means it has higher
efficiency, which naturally results in the lower level of remaining work.
Similarly, in Fig. 15 (b), we can conclude that the module with higher
centrality (i.e., lower efficiency) gets the larger investment for improving
its performance. As for the design rules, Fig. 15 (c) shows the relation
between the investment in design rules and its centrality in the WTM network.
From the linear regression line, we can see that the correlation is not very
strong, but there is still a tendency that the design rule with the higher
edge centrality (i.e., connects the two lower efficiency modules) tend to
attract more resources. Finally, Fig. 15 (d), we can see that there is a
strong correlation that the investment in the module with higher centrality
(i.e., lower efficiency) coincide with the total investment in its
dependencies. Finally, in Fig. 16, we present the evolution of investment in
modules and design rules. As we found in the first case study, we can confirm
the trade-off between the investment in modules and design rules as increasing
trend in modules and decreasing trend in design rules.

##  6 Conclusion and discussion

PD managers are always faced with the problem of making resource allocation
decisions. Especially, when there are several investment rounds, making
optimal decisions based on intuition or heuristic rules becomes rather
difficult. Although, some literatures have proposed analysis methods on
complex network theory Braha2004 ; Braha2004a ; Batallas2006 ; Braha2007 ;
Collins2009  and dynamic linear systems Smith1997 ; Yassine2003 , they lack of
an analytical and mathematical optimization framework similar to the one
presented in this paper.

Our results provide PD managers with an efficient tool to allocate development
resources optimally for the budget-constrained problem and performance-
constrained problem, where the resources can be allocated on both modules and
design rules. Although we carried out the experiments with two types of
problems, and with different product architectures for each problem, the
evolution of the investment and remaining work exhibit similar trends, which
shows that the evolution property of the PD process is independent of the
problem formulation and product architecture. Moreover, the investment and
performance in modules also illustrate that certain correlations exist despite
the problem formulation and product architecture, which also confirms that
these trends and correlations are the intrinsic properties of the PD process.

In the analysis of different PD architectures, we show that the architecture
of the product affects resource allocation which in turn affects the
performance of the PD process. Design and managerial guidelines can result
from the direct analysis of the PD architecture. Specifically, for development
engineers, our result can be used for selecting the product architecture which
leads to maximum performance. On the other hand, when the PD architecture is
fixed, our proposed framework helps PD managers in deciding on the optimal
budget proportions to be allocated to modules and to design rules.

Furthermore, for making a further utilization of our framework, we discuss the
feasibility of adding the linear regression lines for exploring the
possibility of making resource allocation decisions without the need for
solving the optimization problem (i.e., directly by utilizing the correlation
results). In other words, our proposed framework allows us to gain insights
into the relationship between the investment and the DSM architecture, which
inspires us to further investigate and model the mapping from the centrality
of a module to its investment. From the results in Section 4.5, we know that
the DSM architecture affects the resource allocation which in turn affects the
performance. Specifically, from the regression lines in Figs. 7-9, we observed
that the slope in each figure varies among different DSM architectures, which
indicates that modeling a general investment function for all the DSMs is not
feasible. However, if we fix the DSM architecture and the problem size (i.e.,
number of modules and design rules), is it possible for us to address this
problem? From the problem formulation in Section 2, we know that there are
numerous parameters in the WTMs and the cost functions that can affect the
shape of the regression line. Currently, we cannot determine what DSM
parameters influence the slope of the regression line.

One limitation of the framework proposed in this paper is that it does not
consider the time-delay effect; so, dynamic investment problem with time-delay
need to be considered in future work; especially, if the parameters of the PD
system are updated after a certain period. Then, the investment decision
making problem becomes applicable to a more general situation.

## References

  * (1) Ahmad, R.A., Yassine, A.: Experimenting with the NK and DSM models. In International Dependency and Structure Modeling (DSM) Conference. The 20th International DSM Conference, pp. 47-57 (2018)
  * (2) Alcaraz, J., Maroto, C., Ruiz, R.: Solving the multi-mode resource-constrained project scheduling problem with genetic algorithms. Journal of the Operational Research Society 54(6), 614–626 (2003)
  * (3) Baldwin, C.Y., Clark, K.B.: Design Rules. The MIT Press (2000)
  * (4) Barabási, A.L., Albert, R.: Emergence of scaling in random networks. Science 286(5439), 509–512 (1999)
  * (5) Batallas, D., Yassine, A.: Information leaders in product development organizational networks: social network analysis of the design structure matrix. IEEE Transaction on Engineering Management 43(4), 570–582 (2006)
  * (6) Benesty, J., Chen, J., Huang, Y., Cohen, I.: Pearson Correlation Coefficient. Springer (2009)
  * (7) Boctor, F.F.: A new and efficient heuristic for scheduling projects with resource restrictions and multiple execution modes. European Journal of Operational Research 90(2), 349–361 (1996)
  * (8) Boyd, S., Vandenberghe, L.: Convex Optimization. Cambridge University Press, Cambridge (2004)
  * (9) Boyd, S., Kim, S.J., Vandenberghe, L., Hassibi, A.: A tutorial on geometric programming. Optimization and Engineering 8(1), 67–127 (2007)
  * (10) Braha, D., Bar-Yam, Y.: Information flow structure in large-scale product development organizational networks. Journal of Information Technology 19(4), 244–253 (2004)
  * (11) Braha, D., Bar-Yam, Y.: Topology of large-scale engineering problem-solving networks. Physical Review E 69(1), 016113 (2004)
  * (12) Braha, D., Bar-Yam, Y.: The statistical mechanics of complex product development: empirical and analytical results. Management Science 53(7), 1127–1145 (2007)
  * (13) Christensen, C.M.: Disruption, disintegration and the dissipation of differentiability. Industrial and Corporate Change 11(5), 955–993 (2002)
  * (14) Collins, S., Yassine, A., Borgatti, S.: Evaluating product development systems using network analysis. Systems Engineering Journal 12(1), 55-68 (2009)
  * (15) Erdös, P., Rényi, A.: On random graphs I. Publicationes Mathematicae Debrecen 6, 290-297 (1959)
  * (16) Frenken, K., Mendritzki, S.: Optimal modularity: a demonstration of the evolutionary advantage of modular architectures. Journal of Evolutionary Economics 22(5), 935–956 (2012)
  * (17) George, P., Remon, P., Ahmad, B.: Development of a DSM-based methodology in an academic setting. ASME Journal of Mechanical Design 134(2), 021007 (2012)
  * (18) Joglekar, N.R., Yassine, A., Eppinger, S.D., Whitney, D.E.: Performance of coupled product development activities with a deadline. Management Science 47(12), 1605–1620 (2001)
  * (19) Luo, J.: A simulation-based method to evaluate the impact of product architecture on product evolvability. Research in Engineering Design 26(4), 355–371 (2015)
  * (20) Maier, J.F., Wynn, D.C., Biedermann, W., Lindemann, U., Clarkson, P.J.: Simulating progressive iteration, rework and change propagation to prioritise design tasks. Research in Engineering Design 25(4), 283-307 (2014)
  * (21) Newman, M.: Networks. Oxford University Press (2010)
  * (22) Ogura, M., Harada, J., Kishida, M., Yassine, A.: Resource optimization of product development projects with time-varying dependency structure. Research in Engineering Design 30(3), 435–452 (2019)
  * (23) Ogura, M., Kishida, M., Lam, J.: Geometric programming for optimal positive linear systems. IEEE Transactions on Automatic Control, DOI: 10.1109/TAC.2019.2960697 (2020)
  * (24) Reich, Y. Levy, E.: Managing product design quality under resource constraints. International Journal of Production Research 42(13), 2555–2572 (2004)
  * (25) Rivkin, J.W., Siggelkow, M.: Patterned interactions in complex systems: implications for exploration. Management Science 53(7), 1068–1085 (2007)
  * (26) Smith, R.P., Eppinger, S.D.: Identifying controlling features of engineering design iteration. Management Science 43(3), 276–293 (1997)
  * (27) Sosa, M., Mihm, J., Browning, T.: Degree distribution and quality in complex engineered systems. Journal of Mechanical Design 133(10), 101008 (2011)
  * (28) Stellman, A., Creene, J.: Applied Software Project Management. O’Reilly Media, Sebastopol, CA (2005)
  * (29) Tabachnick, B.G., Fidell, L.S.: Experimental Designs Using ANOVA. Duxbury (2007)
  * (30) Terwiesch, C., Ulrich, K.: Managing the opportunity portfolio. Research-Technology Management 51(5), 27–38 (2008)
  * (31) Ulrich, K.: The role of product architecture in the manufacturing firm. Research Policy 24(3), 419–440 (1995)
  * (32) Ulrich, K.: Product Design and Development, 4th McGraw-Hill, Inc, New York (2008)
  * (33) Ulrich, K.T., Eppinger, S.D.: Collective dynamics of ‘small-world’ networks. Nature 393(6684), 440–442 (2008)
  * (34) Yassine, A., Joglekar, N., Braha, D., Eppinger, S., Whitney, D.: Information hiding in product development: the design churn effect. Research in Engineering Design 14(3), 145–161 (2003)
  * (35) Yassine, A.: Managing the development of complex product systems: an integrative literature review. IEEE Transactions on Engineering Management, 1–18 (2019)
  * (36) Yassine, A., Naoum-Sawaya, J.: Architecture, performance, and investment in product development networks. Journal of Mechanical Design 139(1), 011101 (2016)
  * (37) Yassine A., Wissmann L.A.: The implications of product architecture on the firm. Systems Engineering 10(2), 118–137 (2007)
  * (38) Yu, T.L., Yassine, A., Goldberg, D.E.: An information theoretic method for developing modular architectures using genetic algorithms. Research in Engineering Design 18(2), 91–109 (2007)

## Appendix

In this appendix, we illustrate how we can reduce Problems 1 and 2 to convex
optimization problems. We introduce the following notations for cost
functions. For the total cost function in (3), we define

$\displaystyle
B_{k}^{+}(\phi_{k},\gamma_{k})=\sum_{i=1}^{n}f_{i}^{+}(\phi_{i,k})+\sum_{i=1}^{n}\sum_{i\neq
j}g_{ij}^{+}(\gamma_{ij,k}),$ $\displaystyle
B_{k}^{-}(\phi_{k},\gamma_{k})=\sum_{i=1}^{n}f_{i}^{+}(\bar{\phi}_{i,k})+\sum_{i=1}^{n}\sum_{i\neq
j}g_{ij}^{+}(\bar{\gamma}_{ij,k}).$

Let us first show that Problem 1 reduces to solving a convex optimization
problem. Notice that the optimization problem (4) is equivalent to

$\displaystyle{\operatorname*{\ \ \ \text{minimize}\ \ \ }_{\phi,\gamma}}$
$\displaystyle\sum_{i=1}^{n}P_{i}(T)$ (7a) $\displaystyle\operatorname*{\ \ \
\text{subject to}\ \ \ }$ $\displaystyle
B_{k}(\phi_{k},\gamma_{k})\leq\bar{B}_{k},$ (7b)
$\displaystyle{0<\underaccent{\bar}{\phi}_{i,k}\leq\phi_{i,k}\leq\bar{\phi}_{i,k},}$
(7c)
$\displaystyle{0<\underaccent{\bar}{\gamma}_{ij,k}\leq\gamma_{ij,k}\leq\bar{\gamma}_{ij,k},}~{}{k=1,\dotsc,T.}$
(7d)

Under this notation, we can show that the solution of the budget-constrained
problem is given by

$\phi=\exp[x],~{}\gamma=\exp[y],$ (8)

where $\exp[\cdot]$ is the entrywise exponential function of the variables,
and $x=\\{x_{k}\\}^{T}_{k=1}$ and $y=\\{y_{k}\\}^{T}_{k=1}$ solve the
following _convex_ optimization problem:

$\displaystyle{\operatorname*{\ \ \ \text{minimize}\ \ \ }_{x,y,\Gamma}}$
$\displaystyle\Gamma$ (9a) $\displaystyle\operatorname*{\ \ \ \text{subject
to}\ \ \ }$ $\displaystyle\log
B_{k}^{+}(x_{k},y_{k})\leq\log(\bar{B}_{k}+B_{k}^{-}),$ (9b)
$\displaystyle\log{\sum_{i=1}^{n}P_{i}(T)}{\leq\Gamma},$ (9c)
$\displaystyle\log\underaccent{\bar}{\phi}_{i,k}\leq
x_{i,k}\leq\log\bar{\phi}_{i,k},$ (9d)
$\displaystyle\log\underaccent{\bar}{\gamma}_{ij,k}\leq
y_{ij,k}\leq\log\bar{\gamma}_{ij,k}.$ (9e)

Let us give a brief proof of this statement. Under Lemma 1, it can easily be
seen that (7a), (7b), and (7d) in the budget-constrained problem are
equivalent to (9b), (9c), (9d), and (9e). Therefore, the solution of the
optimization problem (9) given by (8) is the solution of the budget-
constrained problem. Under this equivalence, we show the convexity of the
optimization problem (9). It is sufficient to show that constraints (9b) and
(9c) are convex if the performance functions (7a), (7b) and the cost function
(3) follow Definition 1.

We can similarly reduce Problem 2 to a convex optimization problem. We can
specifically show that the solution of the performance-constrained problem is
given by (8), where $x=\\{x_{k}\\}^{T}_{k=1}$ and $y=\\{y_{k}\\}^{T}_{k=1}$
solve the following convex optimization problem

$\displaystyle\operatorname*{\ \ \ \text{minimize}\ \ \ }_{x,y,\Psi}$
$\displaystyle\Psi$ $\displaystyle\operatorname*{\ \ \ \text{subject to}\ \ \
}$ $\displaystyle\log{\sum_{i=1}^{n}P_{i}(T)}{\leq\log\bar{P}},$
$\displaystyle\log\sum_{k=1}^{T}B_{k}^{+}(x_{k},y_{k})\leq\log\left(\Psi+\sum_{k=1}^{T}B_{k}^{-}\right),$
$\displaystyle\log\underaccent{\bar}{\phi}_{i,k}\leq
x_{i,k}\leq\log\bar{\phi}_{i,k},$
$\displaystyle\log\underaccent{\bar}{\gamma}_{ij,k}\leq
y_{ij,k}\leq\log\bar{\gamma}_{ij,k}.$

We omit the proof of this statement because it is similar to the one for the
budget-constrained problem.