2.1. Structural analogies

2.1.1. LSA, analytic design formulations, and nonanalytic incidence matrix design formulations

In LSA, a corpus of linguistic data is converted into a word-by-document matrix. Rows represent words and columns represent documents in which the words appear (Fig. 1a). The matrix entries are a measure of the number of times a word appears in a specific document. If we draw a structural analogy between words in sentences (natural language) and design variables in functions (analytic mathematical language), a similar matrix representation could be developed for analytically stated design problems. Rows would represent design elements (variables, parameters) and columns would represent relationships between these elements (objective functions, constraints). The matrix could thus represent the semantic “meaning” of the design through relationships between variables and functions. Figure 1b shows an example formulation: an analytic, nonlinear, single objective optimization model for a hydraulic cylinder. Figure 1c shows the matrix representation for this problem. Each entry measures whether the variable/parameter occurs in a function. We call this occurrence matrix A. The semantic meaning is recast through this occurrence matrix by capturing the associative patterns between sets of elements (words or variables, and, in general, components of a domain) and experiences (documents or functions, and, in general, syntactic structures composed of those elements).

Fig. 1.

(a) A latent semantic analysis word-by-document example based on Landauer and Dumais (1997), (b) a single objective hydraulic cylinder problem based on Papalambros and Wilde (2000), and (c) a design occurrence matrix single objective hydraulic cylinder problem.

In LSA terminology (Landauer & Dumais, Reference Landauer and Dumais1997), the matrix captures how events occur in episodes. This matrix form plays a crucial role in embedding the multiple pathways by which relations between events and episodes exist. It is these pathways that SVD uncovers. Mathematics, as a formal language for design representation, has the advantage of defining precise relations between variables and functions. Yet, it also has the disadvantage of the formality of mathematics in that the relation between input and output, variable and function, is largely fixed; sophisticated graph-based techniques are needed to “unfix” the relations. Michelena and Papalambros (Reference Michelena and Papalambros1997), for example, review these methods and present a hypergraph-based algorithm that decomposes a design problem into weakly connected subproblems.

The occurrence matrix form can be used to represent both analytically and nonanalytically formulated problems. The functional dependence table (FDT) form (Li & Li, Reference Li and Li2005) is an established method of representing an analytic formulation as a nonanalytic matrix formulation, or of representing relationships between design variables based on results from numerical simulations. It has a direct structural correspondence with the word-by-document matrix in LSA. In this general structural analogy, the matrix measures how elements occur in the local context of one another. A notable difference is that linguistic analysis uses very large matrices derived from very large corpora of natural language. In contrast, matrices from the design domain are restricted to the size of the individual design problems and are likely to be much smaller in size. It is not a priori obvious whether SVD could uncover the multiple pathway relations between variables and functions, and this is an important research question.

2.1.2. DIP and nonanalytic design structure matrix (DSM) formulation

In the DIP domain, SVD is widely used for image compression tasks. An image is converted into a matrix of size m × n; the mn matrix entries contain measurements of pixel values (Kalman, Reference Kalman1996; Fig. 2a). A structural analogy between pixel-to-pixel mappings (image processing) and design element-to-design element mapping (nonanalytic design representation) can be drawn. A similar matrix representation already exists as an established nonanalytic form of design problem representation: the DSM (Sosa et al., Reference Sosa, Eppinger and Rowles2003; Fig. 2b). The example DSM representation shows an aeroengine problem with 54 design components in eight subsystems. Similar DSM representations also exist for mappings such as tasks and processes. The analogy, at this point, is only drawn in a structural way, as no obvious similarity exists between what the image matrix represents and what the DSM represents. In a general structural sense, however, the matrices correspond to relationships that exist between the same elements within a knowledge domain in rows as well as columns. Although image matrices can be square or rectangular, DSM matrices are always square.

Fig. 2.

(a) A 24 × 24 image prepared by Kevin Kirby for D. Kalman, A singularly valuable decomposition: the SVD of a matrix, College Mathematics Journal 27(1), 2–23. Copyright 1996 ASME. Reprinted with permission. (b) A design structure matrix representation from M.E. Sosa, S.D. Eppinger, and C.M. Rowles, Identifying modular and integrative systems and their impact on design team interactions, Journal of Mechanical Design, 125, 240–252. Copyright 2003 ASME. Reprinted with permission.

2.2. Behavioral analogy

However diverse the structural analogies may appear, they seemed deserving of a deeper analysis. We found that the same approach is also a widely used one in many other knowledge domains such as design text, content, and team performance analysis (Dong, Reference Dong2005), prediction of psychological phenomenon (Wolfe & Goldman, Reference Wolfe and Goldman2003), internet search algorithms (Strang, Reference Strang2003), and clustering gene microarray data (Liu et al., Reference Liu, Hawkins, Ghosh and Young2003). We therefore turned to a behavioral analysis of the mathematical structure of SVD to draw a behavioral analogy.

SVD factorizes a general rectangular matrix A with m rows and n columns by decomposing it into a product of three matrices, A = USV^T, where U (m × m) and V (n × n) are the left and right singular matrices, and S (m × n) is a rectangular matrix with r nonnegative singular values that capture the dominant association patterns in the data in decreasing order of magnitude. The number of singular values is r, where r is the rank of A. The mathematical idea (Strang, Reference Strang1993, Reference Strang2003; Fig. 3) is as follows: the row space of A is r-dimensional and inside Rⁿ, and the column space of A is r-dimensional and inside R^m. We choose special orthonormal bases V = (v₁, v₂, … , v_r) for the row space, and U = (u₁, u₂, … , u_r) for the column space, such that Av_i is in the direction of u_i. s _i provides the scaling factor and Av_i = s _iu_i. In matrix form, this becomes AV = US or A = USV^T. Thus, a general rectangular matrix A is diagonalized into two independent spaces represented by special orthonormal bases U and V, and related to each other by the magnitudes of the singular values. A well-known result in linear algebra is that if a dimensionality reduction is performed on this decomposition using the first k largest singular values, then this produces a linear least squares approximation of A. This dimensionality reduction step strengthens the most important association patterns of matrix A (through the first k singular values) and weakens the less important ones, treating them as noise (the r – k singular values).

Fig. 3.

(a) Orthonormal bases that diagonalize A and (b) a geometrical interpretation of transformation in two dimensions. Both from G. Strang, Introduction to Linear Algebra, Wellesley–Cambridge Press, Wellesley, MA. Copyright 2003 Wellesley–Cambridge Press. Reprinted with permission.

2.3. Behavioral characteristics from SVD and dimensionality reduction

Based on the above discussion, the following behavioral characteristics are interesting for extracting semantic meaning from design representations.

4.1. Selection of design elements and relationships

One of the first steps in formulating a design problem are decisions about which design elements to consider as decision variables, which ones to fix as parameters, and what functional relationships to consider between the chosen elements. Often, these decisions are based on previous experiences of a designer and the physics of the problem being modeled. It is likely that problems of the same class will share a similar set of design elements. Also, because design variables are semantically linked in terms of behavioral relationships (e.g., the hoop stress s should be less than a maximum value S), when a designer considers one element as a variable, it becomes important to know what other elements and relationships should be considered in conjunction. This semantic knowledge, as we have seen in the discussion above, is not always explicitly available in the original problem formulation. For example, should the hoop stress equation (h4:s − S ≤ 0) be considered as a part of the model if i is chosen as a variable? Obviously, i does not occur in this equation, so how can one tell a priori?

A measurement of similarity between any one variable and all other variables and functions using a cosine of the angle between them in space can show how this variable is associated with any other. The concept of a cosine threshold is one parameter that a designer can use to experiment with various reformulations. Fixing a cosine threshold, all variables and functions that show higher than threshold cosine measurements with the query variable/function are returned as semantically similar to the query. Recall that the local, explicit, discrete relationships in the matrix A have now been converted into a global, implicit, continuous distance-based representation in real space. Semantic similarity is a continuous function of distance: the higher the cosine value (smaller angle), the higher the semantic similarity. Thus, a higher cosine threshold implies a “tighter” definition and returns fewer coupled variables and functions, whereas a lower one “relaxes” the definition and returns more. By varying cosine thresholds and observing different groups returned as answers, the designer can observe different possible formulations. If we fix i as the query variable, then Figure 8a shows the cosine measurements between i and all the other variables and functions in the k = 2 space. If we choose a cosine threshold of 0.7, then {t, s, p, g3, g4, h1, h2} are returned as semantically related to i. If we increase it to 0.8, then {p, s, h1, h2} are returned. It is clear that the threshold of 0.8 returns only the variables and functions that i explicitly occurs with or in, but a threshold of 0.7 also includes variables and functions that share an implied relationship. This can be confirmed from Figure 8b, which shows the variables and functions returned with the cosine threshold set to 0.7. The query on i returns functions g3: p − P <= 0 and g4: s − S <= 0. i does not occur in either of these, but as we will show in the next section, they are important functions to consider for variable i.

Fig. 8.

(a) Cosine measurements of i with all elements and relationships and (b) elements and relationships returned for query variable I, cosine threshold = 0.7.

A “good” choice of a cosine threshold will lead to “good” reformulations. As a heuristic for identifying good cosine thresholds, we have developed a matrix reordering algorithm that reorganizes a cosine measurement matrix (a matrix where row i and column j are represented by variable i and function j, I = 1 to m, j = 1 to n; matrix entry A _ij measures the cosine between variable i and function j in k-reduced space, refer to aeroengine problem presented later) to cluster variables and functions sharing similar cosines to reveal block matrices on the diagonal with similar cosine values. Alternatively, we have also applied the k-means clustering algorithm on the k-reduced space to reveal these semantically related clusters.

4.2. Heuristic design case identification

The computations shown in the previous sections can be utilized to inform a specific problem reformulation task: design case identification. Any problem formulation model contains a set of constraints. This model could be over- or underconstrained, that is, not well formulated. “Design cases” are sets of active or critical constraints for a design optimization problem formulation that lead to a well-formulated model. One method for identifying these design cases is monotonicity analysis (Papalambros & Wilde, Reference Papalambros and Wilde2000), which is a problem solving by reformulation method in which constraint activity information is used to reformulate the problem to a simpler form when a problem is over- or underconstrained. A significant characteristic to note here is that this process of reformulation is actually similar to discovering previously unobserved implicit relationships between variables, parameters and constraints, that, when made explicit, make solving the problem possible.

In the case of this example problem, there are five design variables, and six design constraints. The number of nonredundant, active constraints cannot exceed the number of design variables for a consistent solution to be found, revealing that there will be design “cases.” All the constraints cannot be active at the same time. There will be sets of active constraints, leading to different cases. Papalambros and Wilde (Reference Papalambros and Wilde2000) identify three design cases: stress-bound, pressure-bound, and thickness-bound. Their results show that for design variable i (internal diameter) either constraints [g3, (g2, h1)] or [(g4, h2), (g2, h1)] will be active, and for variable t (wall thickness) either constraints [(g4, h2), (g2, h1)] or (g1) will be conditionally critical. Figure 9a and b shows that cosine measurements between function vectors in the 2-D space show similar conclusions by purely a syntactic analysis of design formulation. High cosines in Figure 9a are shown as connections in Figure 9b. Cosines between constraints (g2, h1) and (g4, h2) are high, with constraints g3 and g1 sharing high cosines with these two groups, respectively.

Fig. 9.

(a) Design “cases” group identification by method and (b) cosine measurements for groups shown in (a).

Note that monotonicity analysis is a mathematically rigorous, rule-based procedure, and it can identify these cases without ambiguity. Our method can only provide insights into design case “clusters,” and cannot provide optimal solutions as monotonicity analysis does. For example, whereas it shows that there are groups of (g2, h1) and (g4, h2), it cannot tell that these need to be active together as a case. However, monotonicity analysis is applicable only on problems where regions of monotonic behavior in constraints may be identified. This method quickly turns into a very complex solution procedure for even a small–medium-sized problem as the number of variables and constraints increase. Our method would be particularly suited for such large problems, where, if used in conjunction with monotonicity analysis, will be able to focus a designer's attention on possible design cases to consider as semantically related variables and functions. An added advantage of the method is that it can be used to identify semantically related groups for analytic as well as nonanalytic formulations, whether or not functional relationships are available.

4.3. Performance analysis over multiple samples

We have shown that the method requires just one training sample to extract implicit design knowledge. However, a designer may wish to apply the method on several samples of a problem in a specific design domain to explore the implied knowledge returned in these separate cases. We have claimed that the method is training lean, and can identify the multiple as well the invariant aspects of design knowledge, whether it is applied onto one or several design formulation samples of a given design problem.

To analyze the performance of the method over multiple samples, we applied the method on an additional formulation of the same problem. There are multiple ways in which the same problem can be formulated by different designers. Figure 10 shows a multiobjective formulation of the hydraulic cylinder problem (Michelena & Agogino, Reference Michelena and Agogino1988), with conflicting objectives and a slightly different set of constraints and parameters than the single objective formulation.

Fig. 10.

Multiobjective formulation of the hydraulic cylinder problem based on Michelena and Agogino (1988).

The main conclusion to report is that the method generalizes very quickly over very few training examples. By generalizing, we mean that similar and consistent answers are returned for different variations in formulation for the same problem. As seen in the previous section, the method needs just a single formulation to infer the “correct” answers. The answers returned from the multiobjective formulation reinforce this result. The method correctly identifies semantic groupings of variables and constraints within design cases. This is interesting because, in general, computational design support systems require either a very high level of knowledge engineering, or they require a large database of training examples. Although it is possible to automatically generate a training database in numerical optimization cases (Schwabacher et al., Reference Schwabacher, Ellman and Hirsh1998), generating a training database for symbolic cases will be more difficult. Given the specific conditions related to each problem, formulations from the same design domain or even the same problem in different settings can have widely differing mathematical forms (Ellman et al., Reference Ellman, Keane, Banerjee and Armhold1998). Thus, it is difficult to define the learning characteristics and problem representation form for a training database in any general sense. The advantage provided by this method is that it requires only one sample to infer the explicit and implicit design knowledge. Any other samples, incrementally added to the “training database” serve to confirm that the answers are “correct.” All samples are “real” design experiences that either reinforce or change the learning gained from previous samples. The same set of cosine similarity measurements on these two samples reveals that the method returns “correct” answers. For example, parallel to the design case identification task in the single objective case, Michelena and Agogino (Reference Michelena and Agogino1988) use monotonicity analysis to identify three design cases for the multiobjective problem: Case P (pressure inactive), Case S (stress inactive), and Case PS (pressure and stress inactive) with all of the cases having force f and thickness t active. The SVD based method applied onto this example shows (Fig. 11, k = 3) that the pressure and stress groups are distinctly apart, with force and thickness falling in the middle (as supported equivalently by cosine or k-means calculations).

Fig. 11.

Graph representation for dimension reduction, multiobjective cylinder, k = 3.

Because the algorithm is based on extraction of syntactic patterns, it does not discriminate between “wrongly formulated” and “correctly formulated” examples. However, it can be conjectured that over many numbers of design formulation samples, a statistical effect will ensure that the algorithm generalizes “correctly,” assuming that most of the examples provided to the algorithm are “correct” from the design point of view.

The method can be used to capture multiple patterns from the same example by varying the cosine threshold and the k value. The cosine threshold parameter has been discussed in previous sections. We now present the effects of the second parameter: changing the k value (the number of dimensions retained in the dimensionality reduction step) to observe multiple patterns or invariance in formulations. We examine the effect of design problem size on the answers returned, and the number of dimensions k that are retained while performing the dimensionality reduction compared to the number of “correct” answers the algorithm returns. The relevance or “correctness” of the answers returned by the queries was assessed based on how the reformulation suggested by the answers matches up with those provided by the documented results reported in the source paper. For example, in the previous section we present a comparison of the answers returned by the queries from our method with the well-known and documented monotonicity analysis applied to the same problem. Because monotonicity analysis is mathematically proven and guaranteed to find the optimal solution in this case, and our results match those provided by the monotonicity analysis, it may be safely claimed that the answers returned by this algorithm are correct. By studying the effect of problem size and the value of k, we also assess the multiple patterns that are returned as answers, and the invariance of design knowledge across these answers.

4.4. Effect of problem size

Keeping the number of dimensions k fixed, the method pulls more variables, parameters, objectives, and functions as the size of the problem increases. For example, the multiobjective version of the problem contains more variables and constraints than the single-objective version. If we keep the number of k dimensions fixed for both design formulation samples, the number of answers returned to the query variables in the multiobjective case is higher than in the single objective case. Figure 12 shows this result, as over two examples of the same problem with different formulations, we see that the method manages to capture the variances in the formulations. The single objective formulation has an original matrix size of 9 × 7 (Fig. 1c). The multiobjective formulation of the same problem has an original matrix size of 17 × 10, as the multiobjective problem has an increased number of variables, parameters, and objective functions. The method returns a higher number of semantically related groups of variables and functions as answers in the multiobjective case.

Fig. 12.

Answers returned from different formulations of the cylinder problem.

This is an interesting result; it provides proof that the method scales up well. As problem size and the complexity of interaction between variables and functions increases, so will the number of implied relationships. If the method scales up well, it should be able to handle an increase in problem size or complexity without a significant increase in computation time or increase in complexity to the designer to apply the method. A designer wishing to formulate a new problem from the same design problem domain would be able to retrieve different answers to the same query using different samples from the database. They would be able to see how different designers have conceptually “grouped” variables and functions as semantically related to each other. For example, the multiobjective formulation of the problem also uses monotonicity analysis as the design solution method, but because of the differences in formulation, groupings of variables and functions in design “cases” appear different from the single objective formulation. The method captures these differences, and our results show similar groupings of design cases as reported in the two original sources.

The method is also able to capture invariance of design knowledge within the multiple patterns, because the answers returned for the two different cases have overlaps. This implies, for example, that because of the physics of the system being modeled, if i and s are semantically related, then the method applied on both the formulations should return this as a case. If we compare the two example cases, to the query variable i, the single objective formulation returns the set {t, s, p} as related variables, whereas the multiobjective formulation returns the set {t, f, p, s}. Normally, there will be subjective influences in problem formulation: different designers may choose to model the same problem in different ways. However, there may be some invariant design knowledge that will be common across these different formulations because of the physics of the problem.

Our results show that, through the capture of multiple patterns (different answers to the same query in different formulations), the method captures the differences in formulation. Through the capture of invariant design knowledge (same answers to the same query across different formulations) the method captures the basic “physics” in the formulation.

4.4.1. Effect of the number of retained dimensions

Increasing the number of dimensions k shows that the number of variables, parameters, objectives, and functions returned reduces, until the final number of dimensions k becomes equal to the original rank of the matrix, when it returns exactly the same answers as directly available in the original problem formulation. The reduced dimensionality approximation captures hidden design patterns in the problem statement. For different families of designs, experimentation on various problem sizes will lead to the correct or an optimal number of dimensions that give the best results. Heuristically, the “optimal value” of k is the one that leads to well-formulated problems. Problem size, complexity of interactions, and the design domain characteristics all affect the search for the best value of k. For example, in the cylinder design family, because of the relatively small size of the problem, the best dimensions came out to be 2 and 3. Comparing the two formulations, we can see in Figure 12, that in fixing k = 2, the multiobjective version (larger problem size) returns more answers (eight or nine) compared to the answers from the single-objective version (four or five). This is an indication that, sometimes, for very large or complex problems, fixing k to very low values (say 2) can mean that the algorithm is unable to discriminate between conceptually close pattern groups, and it would need more dimensions to bring out the patterns. Figure 13 shows that for the multiobjective formulation, the number of answers returned reduces (and becomes more relevant as “correct” answers) as we increase k from 2 to 3. Beyond k = 4, the performance deteriorates, and the answers returned are not semantically relevant.

Fig. 13.

Answers for different k values for the multiobjective cylinder problem.

In conclusion, the correct dimensionality is best left as a parameter that the user can modify heuristically for various problem classes and sizes. The problem domain, size, and complexity affect the correct value of k. From the mathematics of SVD and dimensionality reduction, it is clear that as the k values approach closer to the rank r (the full approximation) the implied relationships retuned reduce, until by k = r, only the explicit occurrence matrix relationships are returned. Therefore, as a heuristic for choosing a “good” k value, the search is limited to the range of initial k values that return implied relationships when these relations are not evident from the original matrix A. To identify the well-formed reformulations, we choose the k values that returned implicit information, and then used the K-means clustering algorithm or the matrix reordering approach based on cosine measurements. Within this range of chosen k values, if a well-formed reformulation exists, both these methods return such a reformulation in the form of tightly coupled clusters of variables and functions.

5.1. Design decomposition

Figure 2b shows the eight subsystems that form the aeroengine. The system and subsystem definitions have been identified by a team of collaborating designers and industry design experts (Rowles, Reference Rowles1999; Sosa et al., Reference Sosa, Eppinger and Rowles2003). A cross between two components in the matrix shows that they share a design interface or dependency. Thus, in the occurrence matrix A, A _ij is 1 if components i and j share a design interface, and is 0 if they do not. All diagonal entries A _ii = 1 with the interpretation that a component shares a design interface with itself. The 54 × 54 matrix in Figure 2b shows the subsystems already identified. This serves as a validation test: if we merge the subsystem information into a single occurrence matrix, without telling the method about the subsystem definitions that design experts have predecided, will the method be able to identify these subsystems as tightly bound clusters? Thus, the method does not know about the subsystems, only the explicit design dependency information between any two components. Elsewhere, we have shown using small examples (Sarkar et al., Reference Sarkar, Dong and Gero2008) that the method can be successfully used for design decomposition. In this problem, we test the method on performing design decomposition on a large-scale complex problem.

We applied the method to the matrix A, without providing it any identification on subsystem boundaries. The results show that our method is able to identify the subsystem boundaries, keeping a cosine threshold of 0.7, and at k = 2. We use Simon's general definition of a “nearly decomposable system” in which the decomposition should lead to weakly interacting subsystems with strong interactions within each subsystem. In terms of our method, the “strong interactions within each subsystem” clause implies that components of the same subsystem have strong local interactions through shared design interfaces, and will show mutually high cosine measurements. This enables them to be identified as a cluster or chunk. We identify these clusters by using the matrix reordering algorithm on cosine measurement matrices (Figs. 14–16) that cluster together design elements with high similar cosine values, thereby allowing the identification of the cosine threshold.

Fig. 14.

(a) Fan subsystem, (b) low-pressure compressor (LPC) subsystem, (c) high-pressure compressor (HPC) subsystem, (d) combustion chamber (CC) subsystem, (e) high-pressure turbine (HPT) subsystem, (f) low-pressure turbine (LPT) subsystem, (g) mechanical components subsystem, and (h) externals and controls subsystem.

Fig. 15.

(a) Low-pressure compressor (LPC)–fan cosine measures, (b) fan–LPC cosine measures, (c) LPC–high-pressure compressor (HPC) cosine measures, and (d) HPC–LPC cosine measures.

Fig. 16.

(a) Low-pressure compressor–high-pressure turbine (LPC–HPT) cosine measures and (b) HPT–low-pressure turbine (LPT) cosine measures.

Figure 14a–h shows the cosine measurements for the eight subsystems. For ease of visual representation, we show these eight matrices, but they are part of the same large 54 × 54 matrix produced as a result of the SVD decomposition, and can be identified using the matrix reordering algorithm. Note that very few “outliers” do exist (values lower than 0.7). They point to the observation that two specific components within a subsystem do not share a strong local interaction. This is not unlikely; not all components will have strong local interactions with all the others to be defined as a subsystem. The subsystems are identified based on the observation that most measurements within a cluster show cosine values well above 0.9.

Because this method works by measuring distributed “global” patterns of associations between the aeroengine components, it reveals implicit indirect associations as well as explicit ones. Even those components that do not interact directly with each other show a high cosine similarity with each other based on common interaction with a third components. As a simple example, note from the original matrix (Fig. 2b) that, in the Fan subsystem, component 1 shares design interfaces with components 3 and 4 but not with 5. Both components 3 and 4 share a design interface with 5. Now, note that in the original matrix A, there would be a 0 for matrix entry A ₁₅. However, the cosine between components 1 and 5 after the k-reduction comes out to be 0.9948 (Fig. 14a), which is an indication showing that the two share a high semantic relation.

5.2. Modular versus integrative systems analysis

Going back to Simon's definition of a “nearly decomposable system,” there is another clause: that of “weakly interacting subsystems.” Not only will the components within a subsystem show high interaction, as a group, this subsystem will show low interaction with other subsystems. Thus, ideally, components within the subsystems we have identified should show low cosine measurements with all the other components from the other subsystems. We have demonstrated this for small scale problems (Sarkar et al., Reference Sarkar, Dong and Gero2008). In large-scale design problems such as this one, it is rare for a system to be perfectly decomposable. One of the main problems is that it becomes difficult to identify subsystem boundaries, because elements within a subsystem share design interfaces with elements from other subsystems. It is for this reason that we aim for a “nearly decomposable system” rather than a “perfectly decomposable one.” It becomes important now to analyze which subsystems within this large system are modular and which ones are integrative, to reach upon a final decision on the decomposition.

The original source paper provides the following definitions for modular and integrative systems: “a hypothetically perfect modular system would be one whose components do not share design interfaces with components that belong to other subsystems.” On the other hand, a “‘hypothetically perfect’ integrative system would be one whose components are completely physically distributed throughout the product resulting in components that share interfaces with all the systems that comprise the product.” For a perfectly modular system, our method would show very high intra subsystem cosine measurements and very low inter subsystem cosine measurements.

For the aeroengine problem, however, components of one subsystem share design interfaces with components from other subsystems. In such a case, modularity is defined on the basis of the observation that subsystems that share concentrated interactions with only a few other subsystems (i.e., on account of spatial integrity) will be defined as modular. In contrast, subsystems that show distributed interactions with all other subsystems will be defined as integrative. For example, the LPC subsystem is a modular subsystem, because its components share design interfaces with components from the Fan and the HPC subsystems but not with the others. In contrast, the externals and controls subsystem is an integrative one because its components shares design interactions with components from all the other subsystems.

Following up this example in terms of our method, the LPC system should show high cosine similarity with the Fan and the HPC systems but low cosine similarity with the other systems. Figure 15a–d shows that this is indeed the case: the LPC–Fan, Fan–LPC, LPC–HPC, and HPC–LPC matrices show high cosine measurements. Note that the measurements for a pair lead to two different matrices because the original matrix contains asymmetric design relations.

Figure 16 shows, as examples, that the LPC–HPT and HPT–LPC matrices show low cosine similarity as confirmation that the LPC subsystem shows low cosine similarity with the elements from all other subsystems for which it does not share design interfaces with. From our results, the LPC subsystems show low cosine similarity with HPT, LPT, and CC systems.

The external and controls subsystem is identified as an integrative subsystem, as our results show that it has high cosine measurements components from almost all the other subsystems. Our method identifies the Fan, LPC, CC, HPT, and LPT as the modular systems. The HPC system falls somewhere in between the clearly modular and clearly integrative systems: it is more modular than the externals and controls system, but more integrative than all the others. These results match the results reported by the authors in the source paper.

In the source paper, the decomposition of the aeroengine into the eight subsystems was based on information collected from design experts. This information was not provided to our method, but the decomposition suggested by the method “matches” the results produced by human experts. Decomposition of large systems into subsystems is heavily dependent on subjective choices exercised by designers. Frequently, there is no one “right” solution. Using this method, and varying cosine thresholds and k values, designers can use this method to observe multiple decompositions. Last, because the method captures implicit and explicit relationships between design elements in a distributed way, changing just one dependency value in the original matrix will produce changes in all the resulting matrices and cosine values, which may then alter the decomposition decision suggested. This allows designers to experiment with the matrix entries, that is, the dependency matrix in an efficient way to observe how the decomposition decision may change.

6.1. What is the connection between design syntax and semantics?

Whether knowledge in the brain exists in symbolic form (Simon, Reference Simon1995) or is only represented symbolically (Clancey, Reference Clancey1997, Reference Clancey1999) is a lasting debate relevant to any discipline that concerns itself with intelligence and its artificial construction. Design is no exception. Design is a discipline with the pragmatic aim of transforming the world we inhabit into a more desirable future world (Simon, Reference Simon1969/1981; Gero, 1990). Designing, as a process, deals with a defining a formulation that has to be represented to be realized, and yet cannot be defined precisely because it does not yet exist. It is recurrently forced to confront conceptual debates on knowledge and its symbolic reification. The physical realization of any design enacts out the tension between the need to reason with abstract, ambiguous, ill-structured (Simon, 1969/1981) knowledge of the world and the need to represent such knowledge in a symbolic, precise, well-structured way to formalize the processes of designing and production.

Whatever be the form in which knowledge exists in the brain, we know that an observable result of the cognitive activity of designing is the external symbolic representation. We work with the following general hypothesis: If the symbol is a syntactic abstraction produced by the brain (internally or externally), then there is a relationship between the symbolic system of representation and the semantic content that it intends to represents. For design, this implies that there is a connection between the symbolic–mathematical design representation and design semantics. What is this connection?

The basis of pure symbolic AI, the physical symbol system (PSS) hypothesis, gives us the following understanding: “A PSS is simply a system capable of storing symbols (patterns with denotations), and inputting outputting, organizing and reorganizing such symbols and symbol structures, comparing them for identity or difference, and acting conditionally on the outcomes of the tests of identity. Digital computers are demonstrably PSSs, and a solid body of evidence has accumulated that brains are also. The physical materials of which PSSs are made, and the physical laws governing these materials are irrelevant as long as they support symbolic storage and rapid execution of the symbolic processes mentioned above … ” (Simon, Reference Simon1995, p. 104). Following this kind of pure symbolic AI logic, the symbol i is a reference to a physical quantity in the world being modeled “internal diameter for a hydraulic cylinder.” Similarly, symbol s is a reference to a physical quantity “hoop stress in the cylinder.” Symbolic relations and operations exist between these symbols. Inside a computer, there is no notion of symbol to object mapping. The computer needs a human being to interpret that i means “internal diameter.”

Because the mapping is defined by designers, in such “rule” representations, there is a one-to-one mapping between symbol and meaning. However, the preceding quote would suggest that there is no difference in the i as it exists in a computer program and the way i exists in the brain. Symbolic operations between i and s would be the same as inside a human brain and in a computer. We surmise that there must be a difference based on the evidence that humans can produce design formulations and reformulations, but cannot always explain the “rules” by which they do it. Computers, on the other hand, cannot perform this behavior at all; else, it would have been a routinely automated one.

Symbolic AI or expert systems based approaches take a “symbol” to “object in the world” relationship as a given. From this basis, a symbol represents some object or construction in the world. Symbolic operations between these symbols are then encoded as “rules,” and this becomes the definition of “knowledge.” However, the idea of a direct “symbol” to “object in the world” relationship (the original design occurrence matrix A) cannot explain why the design representation should be able to encode “implicit” or “latent” meaning. Why is SVD, which measures syntactical associative patterns, able to reveal implicit semantics that are not explicitly coded into the syntax? Why did we choose SVD as the algorithmic basis for this method?

As the work in this paper shows us, semantic design knowledge is richer than what is directly observable from the sparseness of its external representation. For example, consider that i shares a “deep,” “implicit,” or “latent” relationship with the hoop stress equation “s − S <= 0,” without even occurring in it explicitly. It is hard or impossible to engineer a “symbolic [reasoning] process” based on “comparing them for identity or difference, and acting conditionally on the outcomes of the tests of identity” (Simon, Reference Simon1995, p. 104) to explain such implicit relationships. However, human designers seem to use such associational implicit relationships abundantly, almost in an intuitive, pattern/perceptual recognition sense. Evidently, there is no one-to-one mapping or correspondence between the symbol and its semantic meaning in terms of the reference to the “thing” in the world out there, between design syntax and design semantics. The semantic meaning contained in a single symbol seems to be distributed over the whole system of symbolic representation, and seems to require this whole system to explain its intended meaning. The one-to-one mapping representation (the original design occurrence matrix A) is sparse and the actual frequency of association between a symbol (design element) and its “meaning” within a behavioral relationship (mathematical function, simulation relation, etc.) is extremely low. The simple mapping hides, in a latent way, the richness of associations and correspondences of a different kind.

6.2. “Symbols aren't simple”: Insights from cognitive science and cognitive neuroscience

Clancey explains this dilemma by explaining that the “symbol” does not mean the same thing in a computer and in a human. In a computer, it is an entity referring to a “thing” in an isolated, atomic way. In fact, it needs a human being to make even this interpretive association between the symbol and the thing it represents. Inside a computer, it is just symbols and explicit, fixed associations between symbols: a “flat” relationship. Using the theory of situated cognition and constructive memory, Clancey proposes that, in human reasoning, a symbol is the result of dynamic relations, couplings between perceptual and conceptual categorizations. Such a categorization allows itself to be “restructured,” “recategorized,” or “recoordinated” based on experiences. The same symbol can be a different symbol in different circumstances. In short, Clancey's reformulation of the physical symbol system hypothesis suggests a focus in shift: from the symbol itself to the relations between conceptual categorizations that result in symbolic systems that are not static, but dynamic and changing. In a human being, knowledge is dynamic, because the “meaning” that a symbol captures continues to change as the conceptual categorizations that lie at its basis keep changing. In a new experience, symbols are not simply retrieved from an older experience, copied and acted upon using descriptive rules. Perception, conception, and action arise together as a physical reactivation of categorizations. This he defines in terms of “structural couplings between concepts” and “reactivation and recoordination” processes that can be simultaneous or sequential. We summarize the important point that, in a human being, a symbol is not an isolated atomic entity, but is an abstraction that requires a large body of perceptual and conceptual activations to define it. These develop through experience. It is the dynamic relations activated in experiences that give rise to symbols, and these very same relations that are important in capturing its meaning. Clancey's theory provides insight into the fact that the “dynamic activations of associations, relations and patterns” view lies at the basis of the “rules between things” view. For a “rule” “s − S <= 0” to form, we first need a dynamic activated relation between s and S based on all previous experiences that the reasoning entity has had. The “rule” is a higher order grounded result of lower order activations between concepts and percepts. At the lowest order, all combinatorial associations and relations are possible and plausible as perceptual and conceptual relations. Therefore, two experiences that have the same set of percepts and concepts could still be different, because the set of perceptual conceptual relations activated could be different.

Thus, if symbols result from semantic perceptual conceptual associations, then what can the associations between symbols in design representations tell us about this semantics? The development of expertise in any knowledge domain, including design (Cross, Reference Cross2004), depends on the ability to abstract and generalize patterns or “chunks” of knowledge over and above the structural details of experiences. Experts are able to extract the underlying principles of a design domain from specific experiences. They show a capacity to develop “deep” semantic knowledge from the structural aspects of the problems that they see. This gives an expert a capacity to restructure and reconstruct this knowledge while applying it in novel situations. Further, experts demonstrate top down and breadth first strategies in constructing solutions to design problems: an ability that directly shows that given the same set of design requirements, and similar representational systems, experts pursue a set of multiple solutions. In contrast, novice behavior is characterized by a depth first approach, where given one set of design requirements, they explore a single solution in detail before considering another one. This capacity to redefine the problem and consider multiple solutions is typical to design expertise.

Empirical studies in cognitive neuroscience (Mesulam, Reference Mesulam1998) show that this is a fundamental ability in human reasoning: the ability to extract invariant features from episodic experiences that occur through perceptual conceptual activations and generalize them into abstract concepts,. The abstracted “knowledge” is then independent of the specific details of these episodic experiences. Further, “in translating sensation into action … identical sensory events can potentially trigger one of many reactions, depending on the peculiarities of the prevailing context” (Mesulam, Reference Mesulam1998, p. 1014). Abstraction and generalization of multiple “right” patterns, therefore, seem to be fundamental processes that exist across all ranges and levels of representation. They lie at the basis of the ability to act in a new situation on the basis of what is abstracted and generalized over previous experiences. Carrying this interpretation over to design representations, the SVD method reveals that there can indeed be multiple patterns encoded within a single design representation. There may be multiple potential nondominant reformulations are possible depending upon the level of abstraction (cosine thresholds and k-values). We discussed in Sections 4 and 5, for example, that different design decomposition results appear by varying the cosine threshold and the k-value, and all of these may be considered to be “valid” decompositions.

A symbol is, in a way, the result of the “highest level” of abstraction produced by any species (Deacon, Reference Deacon1997) over perceptual conceptual dynamic activations in experiences. Symbolic reasoning and representation is the hallmark for human beings. It is what sets them apart from other species. To understand how symbols may reify knowledge in design representations, we should explore what kind of abstraction, extraction, and encoding of knowledge happens across experiences that involve symbols in large part, such as design experiences.

Deacon (Reference Deacon1997) uses C.S. Pierce's theory of the three modes of reference: icons, indexes, and symbols. An icon is a reference to an obviously perceived similarity between two things, an index is an indication of some correlation, whereas a symbol is an agreed upon conventional relationship between two things. In this sense, an indexical association is one that exists between a symbol and the object it is referring to. A symbolic association is one that exists between two symbols. He proposes that reference is hierarchical: to be capable of indexical reference is to be already capable of iconic reference, to be capable of symbolic reference is to be already capable of indexical reference. This, however, is only the first proposition. His second, and stronger, proposition is presented by reporting extensive empirical results on actual symbol learning and grounding experiments performed with primates, the chimps Sherman, Austin, and Lana. The proposition is this: “the learning problem associated with symbolic reference is a consequence of the fact that what determines the pairing between a symbol and some object or event is not a probability of their co-occurrence, but rather some complex function of the relationship that the symbol has to the other symbols …” (Deacon, Reference Deacon1997, p. 83) In our case, the symbol is the design variable, and the event or object it is paired to is another variable or behavior expressed through a mathematical function. He is saying that a symbol does not lose its indexical association with the object it is referring to (i to internal diameter of a cylinder) even though there is no direct physical referent present (an actual hydraulic cylinder does not exist yet), because “the possibility of this link is maintained implicitly in the stable associations” between symbols. This is also known as decontextualized meanings, a behavior known only to exist in humans and is a key aspect of human symbolic processing. There is a kind of dual reference in operation: symbols refer to objects (sense); they also refer to each other (reference). Finally, after a symbolic system of representation has been developed through extensive indexical interactions between symbol and object, the mutual reference between symbols is used to pick out the reference between objects and not vice versa. This directly implies that symbols exist contextually in a system: the power of one symbol to explain an indexical meaning about an object is distributed over its associations with all the other symbols that it exists with. Using language as the explanatory domain (we refer to our analogy from Section 2 in the bracketed words), he says (Deacon, Reference Deacon1997, p. 83) “this referential relationship between words [design variables]—words [design variables] systematically referencing other words [design variables]—forms a system of higher order relationships that allows words [design variables] to be about indexical relationships [design structure and behavior], and not just indices in themselves. [This distribution of relations] is also why words [variables] need to be in context with other words [variables] in phrases and sentences [mathematical functions], in order to have any determinate reference [and potential “meaning”]. Their indexical power is distributed, so to speak, in the relationships between words [variables]. Symbolic reference derives from combinatorial possibilities and impossibilities, and we therefore depend on combinations both to discover it (during learning) [design] and to make use of it (during communication) [in our case, design representation].”