## 2 Theoretical Background  
Basically, inference mechanisms as part of a knowledge-based engineering system can be implemented on the basis of model elements and their relations. Depending on how both are modeled, literature distinguishes logic-based, constraint-based and resource-based approaches [13]. For a logic-based representation of knowledge and reasoning, an object-oriented data structure is used [23]. This consists of the actual objects (so-called individuals), logical structures for aggregating objects (concepts) and binary relationships between individual objects (roles). Objects, in a narrow sense, may be understood as classes, from which arbitrarily many instances can be derived and assigned different values. Additionally, the class concept allows attributes of objects to be inherited from higher hierarchy levels. The reasoning is performed by checking whether a special object is included in a superordinate class [11]. Constraint-based approaches represent, as mentioned in the introduction, constraint networks where a constraint represents the relation between two model elements and has a rule for value assignment [13]. In this way, e.g., physical or engineering contexts can be modeled, e.g., the calculation of a bolted connection. Values applied to the constraint network can then be propagated, which means that the values of all other model elements are calculated on their basis. By nature, it is irrelevant according to which variables the formulas are resolved and which variables are used as inputs [24]. CSPs in this application correspond to a system of equations, constraint propagation to the solution of the system of equations. A further very typical task for constraint-based reasoning is the representation of configuration problems. For this, the elements are modeled likewise with their value ranges and relations. An example for this is the so-called map coloring problem [25]. As shown in Figure 1, the single countries are abstracted into domains containing the available colors for the map as values. Inequality constraints are introduced between two neighboring countries, expressing that neighboring countries are to be colored differently [26]. A constraint solver now has the task of finding solutions for the constraint network that satisfy all constraints. For this purpose, different algorithms are available, e.g., Generate-and-Test, which systematically tests possible parameter combinations. However, this method also calculates predictably erroneous value assignments. In the example of the map in Figure 1, _L1_ has an initial value _grey_. The solver then sequentially assigns colors to the other domains and tests the involved constraints. Starting with _L2_ = _white_, the constraint between _L1_ and _L2_ is satisfied. Proceeding to _L3_ = _white_, a constraint is violated, the solution is discarded. The algorithm will then return to the last known state that satisfied all constraints and change the last variable assignment. If _L3_ is then assigned _gray_ instead of _white_, the problem can be further processed and solved. This procedure is called backtracking [26]. Since a constraint network can be written as a graph (the domains form the nodes, the constraints the arcs), alternative algorithms exploit graph-theoretic methods to reduce the effective search space by enforcing local consistency. A CSP is considered node-consistent if all unary constraints, which limit the value of a single variable, are satisfied. Arc consistency involves binary constraints between domains. Inconsistent values from the further involved domain are then immediately removed for the search [12]. For the example in Figure 1, this means that the value _gray_ can no longer be available for _L2_ and _L4_ because _L1_ is already occupied by _gray_ as input. Path consistency extends this by not only collapsing one domain but removing pairs of values from a constraint [26].