How to generate designs based on an automatically constructed design space grammar

Abstract

To provide a method for generating designs based on automatically built design space grammar.SOLUTION: There is provided a system for finding designs for small electrical, mechanical and / or hydraulic mechanisms by exhaustively enumerating a design space given a library of components and a maximum number of components allowed per design. The system functions by creating design space grammar of designs, solving equations associated with parts of the grammar, and putting the solutions into equivalence classes.EFFECT: This dramatically reduces the number of designs that need to be evaluated to check whether to satisfy design criteria.SELECTED DRAWING: Figure 1

Description

[Technical field]

[0001] The following relates to the design of systems and methods for miniature electrical, mechanical, and / or hydraulic mechanisms.

[0002] Currently, most electrical, mechanical or hydraulic systems are designed by people using computer-aided design tools. Although there are some tools for selecting the best parameters for a given conceptual design, there are few tools for automatically exploring the conceptual design space.

[0003] The systems and methods described herein address this need and others in the art. Summary of the Invention

[0004] The approach described herein generates designs given a library of design components by first constructing a design space grammar that covers the design space. By itself, this approach is intractable because the resulting design space grammar is exponential in the number of components allowed in each design. The approach described herein solves this problem by restricting the connectivity of the design space grammar in such a way that the size of the resulting design space grammar is linear in the number of components allowed, even though the number of designs covered by the design space grammar is exponential in the number of components allowed.

[0005] The design space grammar can be used to sample designs in the design space and compare them to the design criteria. The disclosed approach may also include solving equations associated with each part of the design space grammar and placing the solutions into equivalence classes. Using equivalence classes dramatically reduces the number of designs that need to be evaluated. This allows for evaluation of all of the designs covered by the design space grammar when the design has only a few components (e.g., a nail clipper, a mechanism for moving water upwards).

[0006] In one aspect, a system including at least one processor and at least one memory including computer program code, wherein the at least one memory and the computer program code are configured to, using the at least one processor, cause the system to build a design space grammar using a library of components by considering all possible ways that each component in the library can be connected to an interface, the interface comprising a restricted set of connections configured to connect to one of the components or to another interface.

[0007] In some embodiments, in the system described in the previous paragraph, the interface is a primary interface, and the at least one memory and the computer program code are further configured to cause the system, using the at least one processor, to determine an equation associated with a component of the components in the design space grammar, determine an equation associated with each equivalence class of the component's subordinate interfaces, and solve the equation associated with the design space grammar by (i) combining the equation associated with the component with an equation associated with each equivalence class of the component's subordinate interfaces, (ii) simplifying the combined equation, and (iii) placing the simplified combined equation into an equivalence class of the primary interface. The restriction on the restricted set of connections can be specified by a user of the system. The interface may further include a plurality of components that implement the interface.

[0008] In another aspect, a method includes using one or more processors to construct a design space grammar and a design scenario using a component model library; and using the design space grammar to construct a design, wherein the design space grammar comprises interfaces and components from the model library, and the design space grammar is constructed by generating a set of interface rules by iterating over (i) the interfaces and (ii) the components of the model library.

[0009] In some embodiments, the system described in the previous paragraph further includes using one or more processors to recursively connect remaining connections after the iteration by attaching a connection to a first empty connection of the correct type in the interface. The interface may be a primary interface, and the method may further include using one or more processors to determine that an empty connection exists in the primary interface and to add the empty connection to the subordinate interface. In some embodiments, the types of connections include (i) electrical connections, (ii) mechanical connections, and (iii) hydraulic connections. In some embodiments, the interface is a primary interface, and the method further includes using one or more processors to recursively connect remaining connections after the iteration by attaching a connection to the subordinate interface. In some embodiments, the method further includes using one or more processors to recursively connect remaining connections after the iteration, including optionally skipping marked connections. In some embodiments, the method further includes, using one or more processors, recursively connecting remaining connections after the iterations by both (i) attaching a shareable connection to the first empty connection and (ii) attaching a shareable connection to subordinate interfaces for a shareable connection. In some embodiments, the set of rules is a design family, and each rule in the set of rules is a design alternative, and constructing the design includes creating paths through the design family and the design alternatives. In some embodiments, the method further includes, using one or more processors, imposing a limit on the number of connections (m) that an interface can have. In some embodiments, the design includes a design having a conceptual water tank, and the method further includes a human user placing a physical water tank in a location based on instructions in the design having the conceptual water tank. In some embodiments, the method further includes, using one or more processors, constructing the design according to (i) a design space grammar, and (ii) a maximum number of components (n) allowed in the design.In some embodiments, the method further includes using the one or more processors to construct the design according to (i) the design space grammar and (ii) the maximum number of state variables allowed in the design.

[0010] In yet another aspect, there is a system comprising one or more processors configured to construct a design space grammar and design scenarios using a component model library, wherein the design space grammar includes a collection of design families used to implement the design scenarios, each design family including at least one rule corresponding to a design alternative, the collection of design families including (i) at least one design family having only one component and (ii) at least one design family having two or more components, wherein the one or more processors are further configured to: for each design family having only one component, enumerate each design alternative associated with the family, extract equations for each design alternative associated with the family, put the equations in a canonical form, simplify coefficients of the equations, group the equations into equivalence classes, and associate the equivalence classes with the design families.

[0011] In the system described in the previous paragraph, in some embodiments, the one or more processors are further configured to: for each design family having two components, enumerate each design alternative associated with the two components; for each design alternative associated with the family having two components, enumerate equivalence classes of dependent design families; and for each equivalence class of dependent design families, combine equations of the equivalence class of the dependent design family with equations of the design alternative associated with the family having two components, simplify the results of the combination, group the simplified results into a second equivalence class, and associate the second equivalence class with the design family having two components.

[0012] In some embodiments, the one or more processors are further configured to use the equivalence classes to identify potential basic designs, remove components from a potential basic design among the potential basic designs, and if the potential basic design with the components removed still satisfies the design scenario, discard the potential basic design as spurious without removing the components.

[0013] One advantage lies in a novel method for constructing a design space grammar given a library of components, such that the size of the design space grammar is linear in the number of components allowed in the design.

[0014] Another advantage is a novel method for solving the equations associated with the design space grammar by creating equivalence classes such that the number of designs that require evaluation is dramatically reduced.

[0015] Yet another advantage is performance: in some embodiments, an exponential number of candidate designs can be processed in linear time. [Brief description of the drawings]

[0016] [Figure 1] 1 provides an overview of the exemplary systems described herein. [Diagram 2] An example design scenario for moving water upward is shown. [Diagram 3] 1 illustrates an example scenario having a library of small components. [Figure 4] 1 illustrates an example component sequence with a design interface. [Diagram 5] We present the design families of the two-component design space grammar along with the design alternatives and dependent design families. [Figure 6A] 3 shows some example architectures created by the systems and methods described herein for the scenario of FIG. 2. [Figure 6B]3 shows some example architectures created by the systems and methods described herein for the scenario of FIG. 2. [Figure 6C] 3 shows some example architectures created by the systems and methods described herein for the scenario of FIG. 2. [Figure 6D] 3 shows some example architectures created by the systems and methods described herein for the scenario of FIG. 2. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0017] The approach disclosed herein helps find interesting designs for miniature electrical, mechanical, and / or hydraulic mechanisms by exhaustively enumerating the design space given a library of components and the maximum number of possible components per design. The approach works by creating a design space grammar of the conceptual design, solving the equations associated with parts of the grammar, and placing the solutions into equivalence classes. This dramatically reduces the number of designs that need to be evaluated to see if they meet the design criteria. The result is often a small number of base designs that represent the range of possible solutions to the design problem.

[0018] The design process is the task of generating abstract solutions to a design problem. It is shown herein that exhaustive enumeration and evaluation of designs in a design space (e.g., insane designs) is practical for small designs using qualitative reasoning. It is also shown that it is possible to detect when all of the behaviorally singular designs in a given design space have been found, and further shows that under certain conditions, the time it takes to find all possible designs grows linearly with the number of components allowed in the design.

[0019] In the design process, the designer explores the space of possible solutions as well as requirements. This is an ideal problem for qualitative reasoning, which allows for the analysis of potential designs with specified parameters and requirements. Previous work has shown how exploration of component topologies combined with qualitative simulation (sometimes called envisionment) allows for the identification of designs that can yield promising solutions. [Klenk et al., Guiding and verifying early design using qualitative simulation, ASME 2012 International Design Engineering Technical Conferences and Computers and Information in Engineering Conference, pp. 1097-1103, American Society of Mechanical Engineers; 2012].

[0020] The approach disclosed herein addresses two challenges that must be overcome in next generation design tools: First, how to represent exponential set designs, and second, how to efficiently evaluate these designs.

[0021] Some contributions of this disclosure include: First, an automated process for constructing a design space grammar. Second, a morphological analysis of the size of this design space grammar in terms of number of components and number of interconnections. Third, a new method for identifying behaviorally equivalent designs and terminating the search when all behaviorally equivalent designs have been found. Finally, a case study applied to a design problem for moving water upwards.

[0022] The remainder of this disclosure is generally structured as follows: First, the system described herein (e.g., the insane designer) is outlined. Next, the disclosure introduces design space grammars and describes how they are automatically constructed from component model libraries and design scenarios. This is followed by a section describing behavioral equivalence classes and how they are identified. This formal analysis is then complemented with a case study of a design system for moving water upward. Finally, there is a discussion of related work and open problems.

[0023] This disclosure refers to the process of exploring all possible designs as "insane design." With reference to Figure 1, Insane Designer 120 takes as input a component model library 100 and a design scenario 110, and returns all minimal basic designs 170 that satisfy the design scenario 110. In some embodiments, this occurs through the operations of building a design space grammar 130, building equivalence classes 140, filtering through qualitative simulation 150, and identifying basic designs 160.

[0024] The objective is to generate all possible basic designs 170, up to a given number of components that satisfy a given design scenario 110. A design scenario 110 is a set of components and connections with interfaces to the design along with requirements specified as equations for the qualitative values ​​of the components (see FIG. 2).

[0025] 2 shows a sample design scenario for moving water upwards. In this sample design scenario, two tanks 200, 210 are connected to an interface 250. The pressure of one of the tanks 200 is lower than the other 210, and the requirement is that water must flow into the low pressure tank 200.

[0026] Along with the scenario, we consider a library of components that can be used to create designs. Components in the library are resistors, capacitors, and batteries (for electrical domains), pipes and tanks (for fluid domains), torque sources and inertial disks (for rotating domains), pumps and motors (for cross-domain designs) (see Figure 3). The components have topological information (e.g., typed connections that determine how the components can be connected together) and behavioral information (e.g., differential and algebraic equations that link connections within the components). The goal is to find a design made up of components from the library connected according to their typed connections that will satisfy the scenario goals when the design is substituted in place of the placeholder in the design scenario.

[0027] To perform an exhaustive enumeration, some embodiments first create a design space grammar. A design space grammar is a context-free grammar that describes the space of possible designs. All designs that the design space grammar describes are topologically valid designs (e.g., connections between components have the correct type, are not connected to other components or interfaces, there are no dangerous connections).

[0028] When designs are enumerated in a design space grammar for evaluation, they often encounter designs that are equivalent from a behavioral perspective. For example, a capacitor and a resistor in series have the same behavior because they are in series in a lumped element model. In another example, two resistors in series have the same qualitative behavior as one resistor (the two resistors can be replaced by one resistor whose resistance is the sum of the two resistors). Because it is expensive to apply qualitative reasoning to designs to determine whether they meet the goals of a scenario, it is worth grouping equivalent designs into equivalence classes.

[0029] A qualitative simulation (e.g., qualitative reasoning) is performed on the simplest design in each equivalence class to determine whether it satisfies the scenario. (As understood in the art, a qualitative simulation produces a non-numerical description of a physical system and / or the behavior of a physical system. For example, for two resistors in an electric circuit, a qualitative simulation may consider VR1>VR2 rather than considering a specific numerical voltage value for each of the two resistor voltages.) If the simplest design satisfies the scenario, then all of the designs in the equivalence class also satisfy the scenario. The designs can be enumerated in such equivalence classes to obtain all of the designs that satisfy the scenario. Some of these designs are trivial variations of other designs. For example, one design may add a spurious component to another design that satisfies the scenario. This is detected by removing components one at a time from a successful design to see if the design still satisfies the scenario. If so, the design (where no component(s) are removed) is discarded as spurious. If no removal produces a design that satisfies the scenario, then this design is designated as the base design. The output of the insane designer 120 is the set of all basic designs that satisfy the scenario 110 .

[0030] This disclosure analyzes how the performance of the insane design algorithm is evaluated with the number of components allowed in a design. Performing this analysis shows that exhaustive enumeration is impractical except for trivially small design spaces, because the search space becomes very large as the number of components increases. In order to perform exhaustive enumeration, restrictions must be placed on the search space. One goal is to restrict the search space in such a way that the resulting designs are useful and the designer understands the impact of the restrictions. Restrictions are placed on the design space by the user specifying upper bounds on how designs can be interconnected and upper bounds on how many state variables are allowed in the design. These restrictions are explained in later sections.

[0031] Designs may be enumerated by the number of components they contain. Thus, first all one-component designs are enumerated, then all two-component designs are enumerated, etc. Some embodiments build on designs already made in previous iterations, so that three-component designs are built on two-component designs already found. This disclosure shows that it is possible to detect when more regularly unique designs are not found, allowing some embodiments to stop enumerating designs (further designs may be interesting for non-qualitative reasoning). If the enumeration continues, the amount of work required is linear in the number of components added, since the number of unique equivalence classes for each new component remains the same.

[0032] The following describes the design space grammar. A design space grammar has interfaces between a set of components and terminals that are components from the component model library 100. Each interface is defined by a set of connections and the number of components that an implementation of the interface will ultimately contain. In some embodiments, there are two types of rules in the design space grammar: (1) Interface(N) → Component Interface(N-1), where N is the number of components of the interface to the left of the arrow, and (2) Interface(1) → Component. The interface to the left of the arrow is called the primary interface, and the interface to the right of the arrow is called the dependent interface. The rules also include information about how the interfaces are connected to the components and to each other. Some embodiments allow only fully formed rules (e.g., rules where all of the connections have the correct type and there are no empty connections). In some embodiments, an interface is defined by only a set of connections, meaning that the design space grammar can have cycles in it. The presence of cycles makes any algorithm that processes the design space grammar slightly more complicated than described below, but can be handled using standard techniques.

[0033] Some embodiments allow one component and one dependent interface per rule, but it is possible to create complex design topologies with branches in them (e.g., designs where one component is connected to three or more other components) because there may be a connection between two interfaces that omits the component of the rule. It is possible to allow more than one dependent interface per rule, but this makes the explanation of the ideas in this disclosure more complicated.

[0034] To understand how design space grammar works, imagine putting a design into use as a sequence of components with external connections on the left (see Figure 4).

[0035] Between each pair of components there is a vertical dotted line that represents an interface. The number above the dotted line (1, 2, 3, or 4) is the number of components to the right of the interface. The interface also contains a set of connections between the components. The region between a pair of interfaces implicitly defines a rule that consists of the components and a set of connections between the components and the interface and between the two interfaces.

[0036] There may be more than one way to implement an interface using a component. All of the rules for a particular interface may be generated by iterating through the components in the library. For each component, some embodiments generate a class of rules for each connection by first iterating through the connection and, if such a connection exists, connecting the connection to the first empty connection in the primary interface of the correct type. Some embodiments then recursively connect the remaining connections in the component. For each connection, some embodiments allow the following options, without limitation: (1) attach the connection to the first empty connection in the primary interface of the correct type; (2) add the connection to a subordinate interface; (3) skip the connection if it is marked as optional; (4) simultaneously attach the connection to the first empty connection in the primary interface and attach the connection to the subordinate interface if the connection is marked as shareable on the component (e.g., a pin on an integrated circuit is marked as shareable). In this regard, if more than one subordinate interface is allowed (as described above), a choice must be made as to which subordinate interface to attach to. In option (4), some embodiments select more than one subordinate interface. If there are any empty connections in the primary interface, they are added to the subordinate interface. When complete, some embodiments create a subordinate interface that has N-1 component count, where N is the number of components in the primary interface.

[0037] A set of rules that implement a primary interface is called a design family, and each rule in a design family is called a design alternative. A design space grammar is a set of design families required to implement the interfaces specified by a scenario. Figure 5 shows a design family in a two-component design space grammar along with the design alternatives and dependent design families (components and their connections are not shown). The design families are ovals and the design alternatives are rectangles. The DF-1 design family is a dependent interface of the DF-2 design alternative.

[0038] Figure 5 shows a graph of the four design families (ovals) in a design space grammar that specifies all two-component designs. This grammar captures 19 designs. Each design is a different path through the tree. There is one path to the top leaf, three paths to each of the next three leaves, and two paths to the last three leaves: (1x1) + (3x3) + (2x3) = 19.

[0039] The following describes an analysis of the design space grammar size. The size of the design space grammar is a function of the number of design families and the number of design alternatives per design family. The number of design families in the design space grammar depends on the number of possible interfaces. The number of interfaces depends on the maximum number of components allowed in our design and the number of connections of the different possible connection sets. The number of connections is a function of the maximum number of components allowed in the design, which is n. To refer to this, each component in the rule can add at most m-1 connections when moving from a primary interface to a subordinate interface, where m is the maximum number of connections of any component in the library. This means that in the worst case, there can be mn connections. Since m is fixed for a given component library, there are at most O(n) connections in the interface.

[0040] If there is only one type of connectivity, then there are O(n) sets of connectivity, one set for each possible number of connectivity (order does not matter). If there are two types of connectivity (e.g. fluid and rotational dynamics), then we are concerned about how many of each there are. Order does not matter, but there may be 0, 1, 2, 3, ..., n different connections of each type possible. Thus, O(n 2 ) different sets of connections. In general, if there are k different types of connections, then in the worst case, k ) different sets of connections. So, if we count the different components that can have interfaces, we get up to O(n k+1) different interfaces. The number of design alternatives per design family is a function of the number of components in the library and the maximum number of connections per component, but not of n. Thus, the size of the design space grammar is in the worst case O(n k+1 ).

[0041] As the number of components in a design increases, it can be seen that the size of the design space grammar grows very quickly, especially in cross-domain designs. To make design generation practical, some embodiments impose a limit on the number of connections that an interface can have, which corresponds to a limit on the connectivity of the entire design. By limiting the number of connections, the design becomes more modular.

[0042] Consider if the maximum number of connections allowed is c. Then the number of distinct sets of connections is a function of c2, but no longer a function of n. Thus, the size of the design space grammar is O(n) in the worst case.

[0043] The following addresses design equivalence: two designs are equivalent if they exhibit the same behavior at their interface. The following only considers linear systems, and therefore there are only four types of equations. The first type arises mainly from definitions and conservation laws (vi are the variables of the system),

[0044] Σ i v i =0.

[0045] Examples of such equations arise from Kirchoff's voltage and current laws.

[0046] The second type arises from constant laws,

[0047] v i =K ij v j .

[0048] An example of such an equation is Ohm's law v=Ri.

[0049] The third type arises from state variables,

[0050]

number

[0051] An example of such an equation describes the behavior of a capacitor:

number

[0052] The fourth type arises from the input,

[0053] v=1.5.

[0054] For example, a battery provides 1.5 volts.

[0055] From systems theory it is known that every system can be described by

[0056]

number

[0057] x is a state variable, and matrices A and B are permutation specific. Unfortunately, in one approach, designs are not complete systems due to external connections and cannot be described in this way. For example, a design consisting only of resistors has three external variables i1, i2, and v. The current through the resistor is determined by how it is connected to other designs. A design may have fewer equations than unknowns. It is a fragment of a system, and only complete systems with many configuration designs can be characterized by equation (1). To reduce the search space, it may be desirable to detect duplicate designs as quickly as possible. These designs may have different component connection topologies and may have different numbers of components. Although a wide variety of types of analysis from systems theory exist, some embodiments apply a simplified approach that offers significant computational advantages. It is computationally expensive to detect all equivalent designs according to systems theory.

[0058] Some embodiments attempt to rewrite the equations into an equivalent set, referencing only the interface and state variables. From the original set of equations, some embodiments use Gaussian elimination to remove all internal non-state variables.

[0059] If (2) below is a set of equations with external variables P11 and P13, positive constants c2 and c4, and state variable P15, then equation (3) below is its simplified equivalent in standard form. Q2=d / dt(c4P 15 ) P9=-c2Q2 P 15 =P1-P 13 P9+P 11 =P1(2) P 15 =P 13 -P 11 -d / dt(c 18 P 15 ) (3)

[0060] The analysis may determine that a set of equations is inconsistent. Some embodiments discard designs that have inconsistent equations. For example, i and c j If is a constant parameter, then the equation c i =-c j are not consistent.

[0061] In most cases, the equation can be simplified to the form shown in Equation 4 below (V i are only interfaces and state variables),

[0062]

number

[0063] All coefficients C i ,D ij ,E ij can be an algebraic function of the parameters of the design. In matrix form,

[0064]

number

[0065] (This is a generalization of the generalized Thevenin form.) Given the lexographic order, some embodiments reduce these equations to a standard form. Designs with a set of equations equivalent to another modulo permutation of the order are equivalent. This approach significantly reduces the space to be searched.

[0066] The following describes an analysis of the number of unique designs. The number of unique designs is a function of the number of equations per design and the number of possible different equations. The number of equations per design is a function of the number of unique variables used by the design, which are the number of external variables and the number of state variables. The number of external variables is not a function of n because the number of connections is limited, but the number of state variables can be a function of n because each component can introduce one or more state variables. Therefore, some embodiments let the user specify the maximum number of state variables allowed in a design. This means that the number of unique variables is no longer a function of n.

[0067] The total number of variables allowed is limited in insane designer 120, so the number of equations in the standard form is limited (there is a maximum of one equation per variable). Thus, the number of equations per design is not a function of n, and the number of variables per equation is not a function of n.

[0068] Unfortunately, the number of different coefficients, n, for each variable is a function of n, since each coefficient can be any algebraic expression of the O(n) component parameters in the design. If it were always possible to simplify the coefficients to a single parameter, then the number of possible unique equations would be limited, and there would be a finite number of unique designs, regardless of the number of components the design may have. This would be true since the limits are set on the number of state variables and the number of connections per interface.

[0069] Finding equivalence classes is discussed below. A design scenario does not impose any conditions on the form of a design other than its external connections and the maximum number of components it can have. Thus, the design itself does not need to be evaluated, only equations that describe its behavior are needed. Some embodiments use a design space grammar to efficiently enumerate all of the singular sets of equations when the embodiment considers design equivalence.

[0070] Some embodiments create equivalence classes where the design family is inverted. In one aspect, this starts with a design family that has only one component. For each design family, some embodiments enumerate each design alternative associated with that family, extract its equations, put the equations in standard form, and simplify their coefficients. When this is done for all of the design alternatives in a design family, some embodiments group the equations into equivalence classes and associate the equivalence classes with the design family.

[0071] Next, some embodiments process a process design family with two components. For each design family, some embodiments enumerate each design alternative associated with that family. For each design alternative, some embodiments enumerate equivalence classes of its dependent design families. For each equivalence class, some embodiments combine the equations of the equivalence class with the equations for the design alternative and standardization, and simplify the result. When this is done for all of the design alternatives, some embodiments group the set of equations into an equivalence class and associate the equivalence class with a design family.

[0072] Some embodiments continue this process for each number of components until the maximum number of components specified by the user is reached. Some embodiments then perform qualitative inference on the minimal designs in each equivalence class to determine whether the scenario goal is met. Some embodiments discard any equivalence classes that do not meet the scenario goal.

[0073] Now, starting with an equivalence class that satisfies the scenario goal, all designs that satisfy the scenario can be enumerated by recursively selecting one design alternative from each subordinate equivalence class, each of which is syntactically well-formed and satisfies the scenario goal.

[0074] The following discusses early termination of the search. As mentioned above, some embodiments stop generating equivalence classes when a design family with a maximum number of components specified by the user is reached. Sometimes it can be detected that no more unique designs are possible, and then the creation of equivalence classes can be stopped early.

[0075] Some embodiments detect that no more singular designs are possible when the number of equivalent classes for each design family in a particular number of components is the same as the number of equivalent classes for the corresponding design family in the previous number of components. For example, Table 1 below shows the number of equivalent classes for a very simple design problem with only four interfaces: Int1, Int2, Int3, and Int4. Each cell corresponds to a design family whose rows indicate the interfaces and whose columns indicate the number of components to the right of the interfaces. Note that starting with 12 components, the number of equivalent classes for each design family is the same as the number of equivalent classes for the corresponding design family in the previous number of components.

[0076] [Table 1]

[0077] Table 1 shows the number of equivalence classes per design family. In an embodiment where we are only interested in behaviorally singular designs, it does not make sense to continue creating equivalence classes after 12 components. However, one reason for continually creating equivalence classes is that new designs may exist that are behaviorally identical to designs found so far, but have other interesting properties based on the topology of their components. If the creation of equivalence classes continues, the amount of additional work performed is linear with the number of components, since it depends only on the equivalence classes in the previous steps.

[0078] The following describes an example of moving water upward.

[0079] To demonstrate the importance of equal classes, the following presents an exemplary case study that applies the insane designer to the problem of moving water upwards. The exemplary scenario (FIG. 2) includes a small library of components: a water tank 300, a pump 310, an inertial disk 320, and a torque source 330 (see FIG. 3), as well as pipes 220, 230, and a fluid ground 240. Some embodiments generate all possible designs from four components up to seven components. This example limits the design constraints to one state variable and three connections per interface.

[0080] [Table 2]

[0081] Table 2 shows the performance of the systems and methods described herein (e.g., the performance of the insane designer 120) with increasing number of components. In this regard, Table 2 shows how the insane designer 120 performs as the number of components increases (qualitative reasoning time is excluded). Note that while the number of designs is clearly exponential, the number of equivalent classes is approximately linear.

[0082] In this regard, Table 2 shows that the systems and methods described herein advantageously improve the technical capabilities of the system. For example, as the number of designs increases from 462 to 64576, the runtime increases by 1 to 21 seconds on a MAC PRO with a 3.5 GHz 6-core INTEL XEON E5. The same calculation without the equivalent classes would take about 2 hours to find all possible 7 component designs on the same machine. Thus, the technical capabilities of any processor(s) operating with the systems and methods described herein are improved by at least this improved runtime.

[0083] For four component designs, the design space grammar has 16 design families and 54 design alternatives. This design space grammar is a clustered representation of 462 different possible designs with only 29 equivalence classes of designs. The process is less complex than the second one. The qualitative reasoner then evaluates the simplest designs from each of the 29 equivalence classes and determines that 16 of them satisfy the scenario. This takes 55 seconds. It then enumerates 292 designs that satisfy the scenario from the 16 equivalence classes. Of the 292 designs, there are 9 unique basic designs, 4 of which are shown in Figures 6A-6D.

[0084] 6A and 6B, designs 600A, 600B include a rotating inertia disk (flywheel) 610 and a torque source that powers a pump 630. In Fig. 6C, design 600C increases the water in the upper tank 650 by adding another tank 660 with more pressure. In Fig. 6D, design 600D includes a water wheel 670, where a descending water tank 690 is used to spin another wheel 680 that raises the water.

[0085] The following describes related work. Automated conceptual design approaches can be categorized by the type of domain knowledge they utilize. The first set of approaches involves using knowledge in addition to behavioral models to build conceptual designs. These techniques can be divided into three groups [Chakrabarti et al., Computer-based design synthesis research: An overview. Journal of Computing and Information Science in Engineering, 11(2):021003, 2011]: (1) Function-based synthesis employ functional decompositions to describe design alternatives [Stone and Wood, Development of a functional basis for design. Journal of Mechanical design, 122(4):359-370, 2000] and hierarchically constrain the search space [Neema et al., Constraint-based design-space exploration and model synthesis. EMSOFT, pages 290-305, 2003]. (2) Analogous design creates new conceptual designs by adapting existing designs that are codified with semantic knowledge in libraries [Goel et al., On the benefits of digital libraries of case studies of analogical design: Documentation, access, analysis, and learning. AI EDAM, 29(2):215-227, 2015]. (3) Graph grammar methods formulate the conceptual design problem as a set of grammatical rules that specify how to modify a graph that represents the design [Kurtoglu et al., Automating the conceptual design process: “from black box to component selection”. AI EDAM, 24(1):49-62 2010].

[0086] A second set of approaches uses only behavioral models of components to identify conceptual designs that match a particular behavior. These methods typically perform optimization or other search methods. For example, genetic algorithms have been used to design analog circuits that match behavioral specifications [Grimbleby, Automatic analogue circuit synthesis using genetic algorithm. IEE Proceedings-Circuits, Devices and Systems, 147(6):319-323, 2000]. Another approach uses quantified satisfaction to design digital [Feldman et al., Design space exploration as quantified satisfaction. arXiv preprint arXiv:1905.02303, 2019].

[0087] Finally, the disclosed technology introduces an insane designer that enumerates designs using a library of component models. Each design is qualitatively verified by the use of qualitative reasoning (e.g., assumptions) in design scenarios that show it can meet the requirements. Thus, the contributions of the disclosed technology include a procedure for automatically generating a scalable design space grammar that captures all possible designs, efficient methods for identifying feasible designs, a systematic analysis of these methods, and an experimental evaluation through a case study of design scenarios for moving water upward.

[0088] In addition to evaluating additional design scenarios, some embodiments connect the insane designer to a quantitative simulator (e.g., Modelica [Fritzson, Principles of Object-Oriented Modeling and Simulation with Modelica 2.1. Wiley-IEEE Press, Piscataway, NJ, 2004]) and use the qualitative model to guide a quantitative parameter search for a set of components. Because qualitative simulation is exponential and is used to evaluate designs, some embodiments explore new qualitative reasoning techniques that only expand the trajectories that may reach the desired behavior. This includes extending the design scenarios with temporal logic. [Vardi, From church and prior to psl. 25 years of model checking, 150-171. Springer, 2008].

[0089] It will be further understood that the techniques disclosed herein may be embodied by a non-transitory storage medium storing instructions readable and executable by an electronic data processing device to perform the disclosed techniques. Such non-transitory storage medium may include a hard drive or other magnetic storage medium, an optical disk or other optical storage medium, a cloud-based storage medium such as a RAID disk array, a flash memory, or other non-volatile electronic storage medium, etc. It will be further understood that the techniques disclosed herein may be embodied by one or more processors.

[0090] It will be appreciated that various of the above-disclosed and other features and functions, or alternatives thereof, may be combined into many other different systems or applications. Various substitutions, modifications, variations, or improvements therein, not presently anticipated or anticipated, may be made by those skilled in the art, which are also intended to be encompassed by the following claims.

Claims

1. 1. A system comprising: At least one processor; at least one memory containing computer program code, The at least one memory and the computer program code, using the at least one processor, provide to the system: constructing a design space grammar using a library of components by considering all possible ways that each component in the library can be connected to an interface; At least one memory configured to Equipped with an interface having a restricted set of connections configured to connect to certain ones of the components or to other interfaces; the interface is a primary interface; The at least one memory and the computer program code, using the at least one processor, provide to the system: determining an equation associated with a component of the components in the design space grammar; determining an equation associated with each equivalence class of dependent interfaces of said component; Equations associated with the design space grammar: (i) combining the equation associated with a component with the equation associated with each equivalence class of the dependent interface of the component; (ii) simplifying the combined equations by putting them into a standard form; (iii) placing the simplified and combined equations into an equivalence class of the primary interface; The system is further configured to solve the problem by:

2. The system of claim 1 , wherein the restrictions on the restricted set of connections are determined by a user.

3. The system of claim 1 , wherein the interface further comprises a plurality of components that implement the interface.

4. 1. A system comprising: Using component model libraries to model design space and design scenarios one or more processors configured to construct a design space grammar using a design space grammar including a collection of design families used to implement the design scenario, each design family including at least one rule corresponding to a design alternative; the set of design families includes: (i) at least one design family having only one component; and (ii) at least one design family having two or more components; the one or more processors: For each design family having only one component, enumerate each design alternative associated with the design family, extract an equation for each design alternative associated with the design family, put the equation into a standard form, and simplify the coefficients of the equation; grouping the equations into equivalence classes and associating the equivalence classes with the design families; The system further comprises:

5. the one or more processors: For each two-component design family, enumerate each design alternative associated with the two-component design family; for each design alternative associated with a design family having the two components, enumerating an equivalence class of dependent design families; For each equivalence class of the dependent design family, combining equations of the equivalence class of the dependent design family with equations of the design alternatives associated with the two-component design family and simplifying the combination result; grouping the simplified results into a second equivalence class and associating the second equivalence class with a design family having the two components; The system of claim 4 further configured to:

6. the one or more processors:

5. The system of claim 4, further configured to: enumerate sample designs of each equivalence class in the design family used by the design scenario; and evaluate at least one enumerated sample design in the design scenario using qualitative reasoning to determine whether the design scenario is satisfied.

7. the one or more processors: Identifying potential base designs using said equivalence classes that satisfy said design scenarios; removing components from a potential basic design of the potential basic designs; if the potential basic design with the component removed still satisfies the design scenario, discarding the potential basic design as spurious without removing the component; The system of claim 6 further configured to:

Images