1. Introduction
Configuration (Felfernig et al. Reference Felfernig, Hotz, Bagley and Tiihonen2014), a longstanding challenge in AI, is gaining renewed attention as manufacturing industries grapple with the challenge of meeting customer demands for high variance and complexity, all while operating under a high level of automation. To achieve this, configuration processes must empower customers to tailor products to their specific needs within a predefined configuration space. This space is designed to seamlessly integrate with subsequent processes (pricing, quotation, manufacturing, resource planning, and delivery), enabling them to be executed in a highly automated manner. Despite the existence of various approaches to product configuration (Felfernig et al. Reference Felfernig, Hotz, Bagley and Tiihonen2014), building and utilizing complex product models for this purpose remains a challenge in industrial settings due to the diversity of methods, representations, and configuration systems available. Furthermore, stakeholders from industry, research, and software development often struggle to align their understanding of the practical application task with the precise semantics of the modeling formalism.
To address this challenge, we propose a curated selection of product model benchmarks that encapsulate the key challenges of product configuration. These benchmarks can serve as a common ground for fostering a meaningful exchange among all stakeholders involved. More precisely, we formulate our benchmarks in the industrial configuration language Coom (Baumeister et al. Reference Baumeister, Herud, Reutelshöfer and Belli2025b),Footnote 1 and distinguish three language fragments of increasing complexity. The basic one, CoomCore, is mainly about (discrete) attributes and resembles a simple constraint satisfaction problem. The extended one, Coom[p], adds partonomies and cardinalities. And the last considered Coom fragment, Coom[x] adds numeric variables and calculations on top of Coom[p]. Each such class is accompanied by an exemplary product model from the domain of bikes, more precisely, a KidsBike, CityBike, and TravelBike model in Coom. Extensions for two of these language fragments called Coom[p*] and Coom[x*], respectively, enable modeling with unbounded cardinalities, where the latter is exemplified by the product model of a CargoBike. These and further scalable product models are bundled together in the CoomSuite (Baumeister et al. Reference Baumeister, Herud, Ostrowski, Reutelshöfer, Rühling, Schaub and Wanko2025a), which is intended to serve as a workbench for experimentation with industrial-scale product configuration problems and, in addition to all benchmark files, contains Coom grammar definitions and further resources related to Answer Set Programming (ASP; Lifschitz, Reference Lifschitz2019).
The workflow for solving Coom-based configuration problems with ASP is outlined in Figure 1. We start by converting product models in the form of a Coom specification and, optionally, a user input into ASP facts. This conversion is guided by a Coom grammar, which is supplied through the CoomSuite. A specialized ASP visitor then processes the resulting parse tree, translating it into a corresponding set of facts. This initial set of facts serves as a direct serialization of the tree structure and is further refined through an ASP encoding tailored to the specific ASP solution being implemented. The refined fact format, in conjunction with its corresponding configuration encoding, comprehensively defines the configuration space. Ultimately, the answer sets representing valid configurations are transformed back into Coom solutions. Additionally, the CoomSuite offers the possibility to interactively solve configuration problems through a Coom-specific but application-independent user interface (UI).
Workflow for solving Coom configuration problems with ASP.
While this workflow is primarily geared towards ASP, it is adaptable in several ways. First, the serialization of Coom specifications can be tailored for different paradigms by utilizing a specialized parse tree visitor. Second, alternative ASP solutions can be investigated by modifying the refinement of the fact format and employing a different configuration encoding.
Our goals in developing the CoomSuite are to provide and evaluate a comprehensive set of product model examples that are:
Accessible Easily understandable for individuals with diverse backgrounds, including researchers and product managers.
Representative Encompass the typical challenges encountered in product configuration over recent decades.
Unifying Serve as a shared reference point for discussions on representations and formalisms in the field.
Facilitative Aid in the development, testing, and comparison of software components designed for product configuration.
Open Freely available for public use and contribution.
To the best of our knowledge, there currently exists no publicly accessible set of product configuration examples that meets our criteria.
The remainder of our paper is organized as follows: Section 2 introduces the CoomCore language and demonstrates its application through the KidsBike example. Section 3 presents our ASP-based approach to product configuration, detailing the refined fact format and ASP encoding. Section 4 outlines various extensions to the CoomCore language which contain commonly used features in product modeling and how they are handled within our ASP framework. These include concepts such as partonomy, cardinalities, and numerics, as well as user input and unbounded cardinalities. Further, an alternative encoding for solver flingo (Cabalar et al. Reference Cabalar, Fandinno, Schaub and Wanko2026) is presented. Finally, Section 5 describes the CoomSuite UI along with its ASP implementation through system clinguin, and Section 6 demonstrates the practical value of the CoomSuite by evaluating alternative ASP solutions against benchmarks of varying complexity levels.
Related work
Early on, a general ontology for representing product configuration problems was introduced in (Soininen et al. Reference Soininen, Tiihonen, Männistö and Sulonen1998), which inspired many of Coom’s concepts. Coom also draws inspiration from other ontologies aiming to represent corporate knowledge in a standardized way (Brunner et al. Reference Brunner, Ma, Wang, Zhang, Wolfson, Pan and Srinivas2007; Coskun et al. Reference Coskun, Heese, Luczak-Rösch, Oldakowski, Paschke, Schäfermeier and Streibel2009), especially in the context of products and industrial manufacturing (Lin et al. Reference Lin, Fox and Bilgic1997; Baumeister Reference Baumeister2018). A wide range of approaches exist for representing and solving configuration problems across various paradigms (Junker Reference Junker, Rossi, van Beek and Walsh2006; Hotz et al. Reference Hotz, Felfernig, Stumptner, Ryabokon, Bagley, Wolter and Felfernig2014). In recent years, ASP has emerged as a promising alternative, as evidenced by several applications (Gebser et al. Reference Gebser, Kaminski and Schaub2011; Felfernig et al., Reference Felfernig, Falkner, Atas, Erdeniz, Uran and Azzoni2017; Gençay et al. Reference Gençay, Schüller and Erdem2019; Herud et al. Reference Herud, Baumeister, Sabuncu and Schaub2022). Moreover, Falkner et al. (Reference Falkner, Ryabokon, Schenner and Shchekotykhin2015) developed an object-oriented approach to configuration by directly defining concepts in ASP, and Rühling et al. (Reference Rühling, Schaub and Stolzmann2023) recently proposed an ASP-based approach rooted in firm mathematical foundations. In the context of interactive configuration, Falkner et al. (Reference Falkner, Haselböck, Krames, Schenner, Schreiner and Taupe2020) conducted a comparative evaluation of various systems, including the ASP solver clingo as well as SAT and CP systems, for their suitability in this context, finding clingo to be as capable as any other system.
Another system for interactive configuration has been developed by Carbonnelle et al. (
Reference Carbonnelle, Vandevelde, Vennekens and Denecker2023), which uses the IDP-Z3 reasoning engine to interactively solve configuration problems specified in the FO
$(\cdot )$
language. This has been successfully applied to various applications such as finding suitable adhesives (Vandevelde et al. Reference Vandevelde, Vennekens, Jordens, Van Doninck and Witters2024) and machine component design (Aerts et al. Reference Aerts, Deryck and Vennekens2022).
Furthermore, in the related context of product-line variability modeling and configuration, the Clafer language (Juodisius et al. Reference Juodisius, Sarkar, Mukkamala, Antkiewicz, Czarnecki and Wasowski2019) has been developed, which allows to capture in a unified way feature models (Felfernig et al. Reference Felfernig, Falkner and Benavides2024), component models, and others. A series of supporting tools (Antkiewicz et al. Reference Antkiewicz, Bak, Murashkin, Olaechea, Liang and Czarnecki2013a) are available of which we highlight the interactive, web-based Clafer Configurator (Antkiewicz et al. Reference Antkiewicz, Bak, Murashkin, Olaechea, Liang and Czarnecki2013a,Reference Antkiewicz, Bak, Murashkin, Olaechea, Liang and Czarneckib).
2. The CoomCore language
In this section, we introduce the CoomCore language fragment through the illustrative KidsBike example. This fragment primarily corresponds to basic constraint satisfaction problems (Dechter Reference Dechter2003), focusing on variables that need to satisfy a given set of constraints. The KidsBike example, presented in Listing 1, encapsulates a simplified product configuration problem and incorporates all the essential language features of CoomCore. Line 1 establishes the definition of a product. This represents the fundamental entity of the object we intend to configure. Note that only one product can be defined within a single Coom file. Inside a product several features are declared (Lines 2–5). A feature is declared by stating its type followed by its name, as in "Color color". In this case, type and name are differentiated solely by capitalization. However, for the type Wheel, we have two distinct names: frontWheel and rearWheel. The type Bool is a built-in type in Coom. In CoomCore, a type of a feature must refer to an enumeration, representing finite domains of predefined choices. A simple example is the Color enumeration in Line 7. Furthermore, enumerations can include attributes to assign specific values to each option. For instance, the Wheel type defines two attributes: size and price (Line 10 and 11), and its options are declared in Lines 13–14. Unlike the Color enumeration, each Wheel option includes additional values for the size and price attributes, enclosed within parentheses. This indicates, for example, that wheel W16 has a size of 16 and a price of 60.
Features in CoomCore can be seen as variables and thus be used for expressing constraints over them. Coom also offers to use attributes of enumerations as variables, for example, by writing frontWheel.size to refer to the size attribute of the feature frontWheel. In general, these variables are called path expressions.
Representation of the KidsBike example in the Coom language
Constraints can be declared within behavior structures. Here, we allow for three types of constraints. In Line 17, a conditional requirement is declared, stating that the size of the front wheel has to be greater than 16 if the color of the bike is Yellow. Such constraints are declared by using the keywords condition and require, followed by a simple logical (comparison) statement. These statements can contain path expressions and constants, numbers, or strings. In Line 23, a condition-free requirement is defined, stating that the size of the front and rear wheel have to be equal.
Another type of constraint is implemented through combination tables. In the example, Lines 19–21 specify that the use of a wheelSupport is obligatory with small wheels. More specifically, this constraint is declared using the keyword combinations in Line 19, followed by a list of path expressions as the table’s column headers. Then, Lines 20 and 21 define the allowed combinations. A table entry can contain multiple values, as illustrated in the rearWheel column. Any combination that aligns with an allow line within the table represents a valid configuration for the product, while those that do not are invalid.
3. Solving Coom-based product configuration with ASP
We now present our ASP-based approach to solving product configuration problems defined in CoomCore. As previously mentioned, we begin by converting a Coom input file into a set of facts that represent the serialized parse tree of the Coom model. This is accomplished by using a custom Python ANTLR v4 parser, which utilizes a Coom grammar, making it easily adaptable to future language upgrades. Next, we transformFootnote 2 the initial set of syntax-reflecting facts into a more refined representation that captures the essential concepts of the configuration problem in view of the configuration encoding at hand. This abstraction allows us to move beyond the specific details of the input format and focus on modeling the fundamental concepts of the configuration problem.
More precisely, the basic concepts of the refined fact format are variables whose type is a discrete attribute over a finite domain. There are two types of constraints over these variables: Boolean and table constraints. For illustration, we present (an extract of) the refined fact format of the KidsBike in Listing 2. Our fact format uses an object-centered representation, which identifies all concepts with terms.
Variables are identified by strings such as "color" or "frontWheel" and their types are declared in Lines 1–3.
Extract of the refined ASP representation of the KidsBike example
Lines 5–7 give the (discrete) attributes of the configuration model. In fact, both the Wheel enumeration and one of its enumeration attributes size from the Coom model are represented as discrete attributes. The Bool attribute is a Coom built-in and added automatically during refinement. We omit showing the Color and price attribute. In Coom, the (combined) values of such attributes are among the enumeration’s options (cf. Section 2). We guarantee their compatibility, for example, of size and price from the Wheel enumeration, by means of a table constraint which is omitted for brevity.
Lines 9–20 give three constraints of the configuration model; they reflect Coom behavior[s]. Each constraint is identified with a term, c0, c1, etc., during refinement. Constraint c0 is a conditional requirement stating that the color Yellow is only available with larger wheels. For this, we require in Lines 19–20 that color=Yellow is false or frontWheel.size>16 is true. These statements are represented by f0 and f1, respectively, and the operators "||" and "!" stand for disjunction and negation, respectively. They are further decomposed via predicates binary/4 and unary/3 until the variable or constant level is reached. Analogously, Lines 14–17 encode a Boolean constraint stating that the size of the front and rear wheel must be equal.
Lastly, Lines 14–17 give a table constraint reflecting a combinations table in Coom. The constraint and its columns are declared in Lines 14 and 15, followed by the table entries in Lines 16 and 17, expressed by predicate allow/3. Note that multiple values can be given for a table entry, as for entries (1,0) and (1,1).
In what follows, we present a simple configuration encoding for CoomCore models in Listing 3. While Line 1 generates exactly one value per discrete attribute from an associated domain, Line 2 generates auxiliary values for constants used in the constraints.
ASP encoding of refined CoomCore
Next, Lines 4–17 encode Boolean and table constraints. To start with, the integrity constraint in Line 4 makes sure that all original constraints are satisfied. Lines 6–13 specify satisfaction conditions for various types of binary and unary formulas making up a Boolean constraint, viz. disjunction (Lines 6 and 7), negation (Line 8), and comparison operators = and > (Lines 10–13). To encode disjunction, we make use of clingo’s weight constraints, where the expression 1 <= satisfied(XL); satisfied(XR) states that at least one of the two subformulas XL or XR must be satisfied.
Lines 15–17 give satisfaction conditions for table constraints. For this, we identify all rows that are not satisfied (Lines 15 and 16). A row is not satisfied whenever one of its entries is not satisfied. Note that as entries can contain multiple values, we employ clingo’s conditional literals to check for all of the individual values within the table entry. Here, the expression not value(X,V) : allow(C,(Col,Row),V) will be expanded to not value(X,V1), not value(X,V2),… during grounding for a table entry containing the tuple (V1,V2,…). More precisely, the expression not value(X,V) : allow(C,(Col,Row),V) gathers all possible values V1,V2,… for a given table entry (Col,Row) of the table constraint C and then expands to a conjunction of literals not value(X,V1), not value(X,V2),…. Finally, a table constraint is satisfied if one of its rows is satisfied (Line 17).
Listing 4 shows how to solve the KidsBike example with the solve mode of the CoomSuite following the workflow from Figure 1. Currently, the CoomSuite uses clingo as the default solver. Here, kids-bike.coom is the input file containing the Coom model of the KidsBike example corresponding to Listing 1. The option –output coom (or -o coom for short) converts the ASP output to a (more readable) Coom format.
Solving the KidsBike example with the CoomSuite
4. Coom language extensions
Having explained the basics of Coom, we now proceed to elaborate on its extensions and how they can be modeled and solved using ASP within our framework.
We begin by showing how more commonly used features like partonomy, cardinalities, and numeric calculations can be modeled within Coom[x], using our TravelBike example for illustration. We do not delve into Coom[p], as all its concepts are already encompassed within Coom[x].
We start by explaining how these features are implemented and how they are used in the TravelBike example. The bike’s partonomy consists of two parts: a carrier and a frame. Both of them can be equipped with zero, one, or multiple bags, thus making bags an optional component. However, the model’s constraints can necessitate a minimum total storage volume greater than zero, effectively requiring the inclusion of at least one bag. To calculate the total storage volume, arithmetic aggregation functions are employed to sum the storage capacity across all bags.
Similar to above, we first outline how these features are modeled within Coom[x] and then demonstrate their representation and resolution using ASP. For this part, we first present the fact format and then proceed to show two similar but alternative encodings: one for solver clingo and one for flingo. For both, we showcase selected aspects and refer the reader to Baumeister et al. (Reference Baumeister, Herud, Ostrowski, Reutelshöfer, Rühling, Schaub and Wanko2025a) for the complete encoding.
In the second part of this section, we use Coom[x] as a basis to describe two less commonly used features which are nevertheless equally important in practice. The first one is so-called user input which allows for the specification of custom requirements at runtime such as for example a minimum total storage volume for the abovementioned TravelBike, thereby excluding certain solutions from the search space beforehand.
The second feature are unbounded cardinalities, which allow modeling cases where the exact (or approximate) number of some object is not known beforehand. Here, we introduce extensions to two of our language fragments, which we call Coom[p*] and Coom[x*], respectively. We illustrate Coom[x*] using the CargoBike example, a modified version of the TravelBike, where the number of possible bags is unbounded. For both, we proceed in the same manner as before by first showcasing a Coom example and then showing how this is solved using ASP.
4.1 The TravelBike in Coom[x]
Listing 5 gives a simplified Coom[x] representation of the TravelBike example. First, the features of the bike are defined, starting with the two numeric ones, totalVolume and requestedVolume in Lines 2 and 3. Both are marked as such by the keyword num at the beginning of the line, followed by their respective ranges. The second feature can be thought of as a user requirement that can be set at runtime (cf. Section 4.4). Next, Lines 4 and 5 define the carrier and frame, whose types are captured by structure[s] in Lines 7 and 8. Both the num keyword and the structure keyword were not possible before in CoomCore. Other than enumeration[s], structure[s] may have features on their own, which allows for building complex partonomies. For example, the Carrier and the Frame structure have exactly one feature, bag. The expressions 0..3 and 0..2 give their respective cardinalities. Strictly speaking, each feature in Coom has a cardinality, but when omitted it defaults to 1..1. In all our Coom fragments until now, lower and upper bounds are mandatory, and we carry this requirement over to our fact format as well (only in Section 4.5 we generalize this to allow for open bounds.) The type of both features is Bag, which in turn is an enumeration with a single attribute volume (Lines 10–13).
Simplified representation of the TravelBike in Coom
Lastly, we discuss the constraints of the model. The first constraint requires that there are no more than four bags in a configuration (Line 15). For this, it uses aggregate functions to count the number of bags. In general, aggregate functions perform calculations over a set of variables, which are defined implicitly in terms of a path expression, for example carrier.bag. In this case, the function count(carrier.bag) returns the actual number of bags attached to the carrier in the configuration at hand.
We introduced path expressions in Section 2 as variables corresponding to a product feature, or an enumeration attribute, respectively. This is valid for CoomCore, however, for Coom[p] and Coom[x] we need a more general definition as features can have cardinalities different than 1. We now say that a path expression serves as an identifier for a set of variables.Footnote 3 Each part of the path expression is a feature name and the last part can be an enumeration attribute.
Another aggregate function is sum, which returns the sum of the values of all variables in a set (Lines 17 and 18). Here, the constraint requires that the value of totalVolume is equal to the sum of the volume of all bags. The last constraint is another requirement and relates the calculated value of totalVolume to the value requestedVolume.
4.2 Solving Coom[x] in ASP
In this section, we outline our ASP-based approach to solving product configuration problems specified in Coom[x]. We start by illustrating the refined fact format representation using the TravelBike example, which incorporates more advanced concepts than the fact format presented in Section 3.
The essential concepts of this new fact format are a partonomy with bounded cardinalities, attributes ranging over discrete or integer domains, and Boolean as well as table constraints where the former now allow for arithmetic expressions and aggregate functions.
We represent the configuration as a tree such that each node represents a variable, and its root reflects the object to be configured. Variables can be either parts or attributes. Solutions are represented as subtrees of this configuration tree where values are assigned to any attribute variable included in the subtree. Thus, not all variables are necessarily included in the solution and an excluded variable renders all variables in its (possible) subtree excluded. Cardinalities are represented as constraints over sets of nodes in the tree.
The TravelBike example converted into a configuration tree.
4.2.1 Fact format
In Coom, a partonomy is established by defining structures and linking them through features. These features can also reference enumerations or numeric variables, potentially with cardinalities (as illustrated in Listing 5). We simplify this approach by treating both part and attribute variables uniformly and refer to the resulting structure as the configuration tree which can be considered an explicit representation of the Coom configuration product model from before.
For the TravelBike, this structure, which serves as the basis for our fact format, is visualized in Figure 2. Here, nodes belonging to parts are highlighted in yellow and those belonging to attributes in green. Consider an example solution where the third bag of the carrier and the second bag of the frame are undefined, thus not included in the solution. We represent this in Figure 2 by highlighting the corresponding variables in a lighter color. Note that undefined variables automatically render their subnodes undefined as well. Note that for the sake of readability variable names are abbreviated and value assignments are omitted. Cardinalities of features are treated by grouping variables belonging to the same feature and with the same parent variable in sets (represented by dashed circles in the diagram).
Our refinement process generates all possible variables within the model and assigns them unique (human-readable) identifiers by leveraging the tree-like structure of the configuration. For example, the frame feature of the product in Listing 5 results in the variable "root.frame[0]". In this context, "root" refers to the object being configured, in our case, the TravelBike. Indices are required as feature cardinalities are potentially larger than 1. For instance, the bag feature of the Frame structure yields two variables "root.frame[0].bag[0]" and "root.frame[0].bag[1]" which can be read as “the first and second bag of the first frame”, respectively. For capturing each such variable in an object-centered representation, we include three facts representing the type, index and parent of the variable.
A variable of the instantiated TravelBike
We represent Coom’s structure[s] as parts. Hence, we encode the TravelBike’s parts as part("Carrier"). and part("Frame"). Since Bag is an enumeration in Coom, it is represented as a discrete attribute (cf. Section 3).
Cardinalities are represented as lower bound constraints. The upper bound is compiled away during our refinement process by generating the corresponding number of variables. For example, the cardinalities for the bags of the frame are encoded as follows:
Cardinality constraint for the bags of the TravelBike frame
While the second argument "lowerbound" of predicate constraint/2 marks its type, the first one contains a pair consisting of an identifier "root.frame[0].bag" and the actual lower bound 0. The identifier acts as a representative for a set of variables. This set is encoded by means of predicate set/2, whose first argument identifies the set and its second one a set member. The upper bound 2 is thus reflected by the number of set elements.
A numeric attribute and its corresponding range is declared as follows:
Integer attribute totalVolume of the TravelBike
As before, a variable is associated with this attribute through predicate type/2, for example type("root.totalVolume[0]","totalVolume"). Currently, the only numeric attribute type is integer.
Aggregate functions are represented in analogy to cardinalities in a set-based fashion.
Count aggregate function of the TravelBike
The predicate function/3 comprises the function’s identifier, its type (e.g., count), and a set identifier. As above, the members of the set are declared via set/2.
Lastly, (binary) arithmetic functions like + or − are represented in the same manner as Boolean binary functions (cf. Listing 2).
4.2.2 Encoding
We now describe selected aspects of our encoding for solving configuration problems in Coom[x]. We start by describing the rules related to the configuration tree.
Definedness of variables in Coom[x]
Line 1 of Listing 10 generates instances of include/1 predicates, stating that a variable of the configuration tree is included in the solution. This rule applies to part as well as attribute variables; the root variable is always included. Line 3 restricts this to variables whose parent variables are included as well. For symmetry breaking, Lines 5 and 6 enforce that a variable with index I is only included if the variable with index I-1 from the same (cardinality) set is included as well. We leverage this for enforcing cardinality constraints in Lines 8 and 9. Since variables in a cardinality set are included in ascending index order, we only need to check that the variable whose index corresponds to the lower bound is included in the solution. Also, a cardinality is only enforced if the parent variable is included in the solution.
Next, we consider numerics in Listing 11 for generating attribute values.
Generation of attribute values in Coom[x]
Unlike Section 3, we now need to take into account possibly undefined (attribute) variables. In our current encoding, we say that an attribute variables is defined iff it is included in the solution. The rule in Lines 1 and 2 is similar to the one above, just that now the body additionally contains the atom include(X). This guarantees that an attribute variable only generates a value if it is included in the solution and thus not undefined. Integer attributes are handled analogously except that values are generated from a range of numbers.
The possible undefinedness of variables also has an effect on constraint satisfaction and violation. For example, in our CoomCore-encoding, a constraint is violated when it is not satisfied. This condition is no longer sufficient here, as variables in a constraint can now be undefined. We therefore need to adapt the integrity constraints accordingly.
Boolean constraint checking in Coom[x]
The integrity constraint in Listing 12 contains the additional atom defined(F), making sure that the Boolean formula F can only be violated if it is actually defined. The predicate defined/1 is specified recursively. An (attribute) variable is defined when it has an assigned value and a binary predicate is defined when both of its parts are defined.
Lastly, we showcase the encoding of arithmetic and aggregate functions.
Numerical calculations in Coom[x]
Listing 13 contains rules for the count and sum aggregate function as well as for the + operator. For all three rules we are making use of built-in clingo functionality. Note that whenever non-domain predicates (include/1 and value/2) occur inside an aggregate, assigning the result of that calculation to another variable possibly creates very large groundings. This is due to the fact that all possible value assignments have to be explicitly represented. However, in this encoding we opted for clarity and simplicity over performance and leave optimized versions for future work.
Solving Coom[x] product models with the CoomSuite works by using its solve mode in the same fashion as already shown in Listing 4 above for the KidsBike example. We do not show the command-line in- and output here but defer this to Section 4.4 where we introduce user input.
4.3 Solving Coom[x] with flingo
An alternative Coom[x] encoding is given for solver flingo Footnote 4 which is a prototype system for solving conditional linear constraints with integer variables in ASP. This system is a continuation of the lc2casp system (Cabalar et al. Reference Cabalar, Kaminski, Ostrowski and Schaub2016) enhanced with conditional linear constraints given via the translation in (Cabalar et al. Reference Cabalar, Fandinno, Schaub and Wanko2020). flingo uses CASP solver clingcon (Banbara et al. Reference Banbara, Kaufmann, Ostrowski and Schaub2017) as a backend, therefore being able to deal with large integer ranges and numerical calculations. The main difference, however, is that variables in flingo can stay undefined while in clingcon all variables need to have a value assigned. As Coom allows for optional attributes, this is a crucial feature. The encoding for flingo is identical in many parts to the clingo encoding from the previous section, except for rules which treat integer attributes and numerical constraints.
We start by giving a brief overview of the flingo features we are utilizing for this adaptation and then proceed to highlight the differences between the two encodings. Our main objective with the flingo encoding is to improve performance for numerical instances by overcoming clingo’s grounding bottleneck. This is achieved in flingo by allowing for a special type of variables which are not subject to grounding. These are called integer variables and as their name suggests, can take values from the domain of the integers. Importantly, they are being treated differently than propositional variables. Further, to be able to properly replace the necessary rules from our earlier encoding, we require that these integer variables can be used to build linear constraints while comprising a notion of undefinedness and the possibility to define defaults. Lastly, we also need to be able to exclude variables from a calculation if they do not fulfill certain conditions, that is aggregate functions should allow for conditionality. flingo provides us with all these features as we see in the following. Rules in flingo are written in the same way as in clingo but additionally there are a few special theory atoms through which we can define integer variables and build up constraints over them. Here, we explain only those theory atoms that we are using in our encoding and refer the reader to Cabalar et al. (Reference Cabalar, Fandinno, Schaub and Wanko2025), Reference Cabalar, Fandinno, Schaub and Wanko2026) for further documentation and examples. We proceed by showing snippets of the flingo encoding while highlighting the differences from the clingo encoding from Section 4.2.2.
First, Line 1 in Listing 14 represents the flingo replacement of the rule in Lines 3 and 4 in Listing 11 which is responsible for generating possible integer attribute values.
Generation of integer attribute values in flingo
The head atom & inL..U =: X assigns a values from the range L..U to variable X. Note that since variable X appears inside the theory atom, it is declared as an integer variables and therefore not subject to grounding. The operator =: specifies that this is an assignment, meaning that X only gets a value assigned if the lower and upper bound of the interval, L and U, are defined. In this case, this would not be necessary as both are constants; however, the current syntax of flingo only allows to use &in together with the assignment operator =:.
Due to the fact that integer variables in flingo are freed from grounding (and unlike in the clingo encoding), it is possible to reason with unbounded ranges (cf. Line 2). When no range is specified, the atom &sumX = X works similar to a choice rule in ASP in the sense that it defines variable X without constraining its range, thus effectively assigning any possible integer value to it.
Next, Listing 15 shows some of the rules for Boolean constraint checking (compare with Listing 12).
Boolean constraint checking in flingo
In Line 1 we make use of flingo’s &df atom to check whether a variable is defined. Binary formulas are checked for satisfaction in the same way as before with the difference that we are using the flingo atom &sum. Recall that since integer variables are treated in a special way in flingo, they may only be accessed in the context of theory atoms (or constraints formed by them as in the case of variable X2).
Lastly, in Listing 16 we show rules for numerical calculations in flingo which correspond to the rules from Listing 13 for clingo.
Numerical calculations in flingo
They represent calculations of count and sum aggregates, as well as for the + operator. While in the earlier encoding a different clingo functionality was used for each rule, here we use the flingo theory atom &sum for all calculations. For the count function, we utilize the &sum atom with weight
$1$
and for the + operator, we explicitly specify the two variables we want to add. For example, the atom &sum 1,X : set(P,X), include(X) = F assigns to variable F the number of variables X that are contained in set P and included in the solution.
As all these &sum atoms appear in the heads of rules, they assign values to variables. Note, however, that here we are not using the directional assignment operator =: but just normal equality. In general, flingo offers two distinct semantics: one, which is evoked by using the operator =:, only assigns a value to the variable on the right side if all variables on the left side are defined. The second one, evoked by using normal equality, has no directionality and forces all variables occurring in the constraint to take on a value. In that case, if both variables in the constraint &sumX = Y were undefined, the constraint would force them to take any value as long as they are equal (which could possibly result in an infinite amount of solutions).
In our case, the rules would behave the same under both semantics because we are already checking for definedness of the variables on the left side by means of the include(X) atom. This is possible due to the conditionality of the aggregate functions mentioned earlier.
We can solve a Coom instance using flingo by adding the -solver flingo (or -s flingo for short) option on the command-line. By default, the CoomSuite uses clingo as solver. We do not show the command-line output here as it coincides with the one from clingo.
4.4 Adding user input
All the Coom language fragments described so far equip the user with the ability to build up a configuration model which can be seen as a blueprint for all possible configurations. Another important concept in configuration is that of user requirements which allows the user to specify knowledge that needs to be included in the current configuration (Soininen et al. Reference Soininen, Tiihonen, Männistö and Sulonen1998). For example, the user could require the solution to include an optional component (e.g., the basket of a bike) or to set the value for an attribute (e.g., defining a minimum number of storage space in the TravelBike).
The CoomSuite allows to perform this via a separate, so-called user input file that can be passed along on the command-line. For these means, the Coom language provides two keywords: add (Line 1) and set (Line 2–3) which respectively, add an object to the configuration and set the value of an attribute. For both, the variable identifiers from the refinement phase introduced in the previous section (cf. Section 4.2.1) have to be used, however, without the quotation marks. An example of such a user input for the TravelBike can be seen in Listing 17.
A Coom user input file for the TravelBike
During parsing and the refinement phase, the Coom user input is converted into user_include/1 and user_value/2 predicates, respectively. Then, before solving, the CoomSuite checks if the user input is valid with respect to the configuration model and gives out warnings in case of inconsistencies. Warnings are given out when:
-
1. The referenced variable does not exist.
-
2. A value is being set for a variable not corresponding to an attribute.
-
3. The value is outside of the attribute domain.
Note that as upper bounds of cardinalities are compiled away during the refinement process, it is not necessary to check for exceeding maximal cardinalities. Instead, this is implicitly handled by the first kind of warning.
Going back to our simplified TravelBike from Listing 5, note that the product model does not have a color feature, and thus the CoomSuite would give out a warning of the first case about Line 2 in Listing 17.
Independently of any warnings, the user input is processed by the encoding in Listing 18. However, before adding any user input to the final configuration, the encoding first verifies for each user_include/1 and user_value/2 that the user input is consistent with the configuration model (Lines 1–3). We omit here the rules for integer domains as the check is similar as for discrete domains.
Solving user input in clingo
For each user_include/1 predicate we check that the object to be added exists. For a user_value/2 predicate we check that the attribute exists and that the value is in the domain of the attribute. Note that these checks only cover simple inconsistency cases and it is still possible for the user to provide inconsistent input such as an invalid combination of attribute values (which might be harder to detect).
Subsequently, in Lines 5–7 the consistent user input is added to the configuration. If the object in an user_include/1 predicate refers to an attribute this assures that a value will be set for this attribute (but the user does not need to specify this value). Any user input not consistent with the configuration model is ignored.
We can solve a Coom instance with user input by using the –user-input option (or -u for short) and passing the path to the user input file as an argument. In Listing 19 we are running the simplified TravelBike example from before with the user input from Listing 17. The CoomSuite prints out a warning for the set color[0] = Yellow directive, as the variable is not part of the configuration model but proceeds to solve the configuration problem, ignoring the incosistent user input.
Solving the simplified TravelBike example together with user input
4.5 Reasoning with unbounded cardinalities
In all earlier Coom language fragments a lower and upper bound for feature cardinalities had to be explicitly specified (or the cardinality defaulted to
$1..1$
if no bounds were given). In practice, however, when modeling a configuration problem, it is often not possible to determine the exact (or even approximate) number of objects needed in advance (Taupe et al. Reference Taupe, Falkner and Schenner2016). In this section we extend Coom[p] and Coom[x] to support unbounded cardinalities and call these Coom[p*] and Coom[x*], respectively. Then, we present a simple modification of our existing workflow to solve problems of such kind.
Listing 20 shows the CargoBike, a slightly modified version of the TravelBike example from Listing 5 such that the number of possible bags is now unknown.
Representation of the CargoBike example in Coom
Workflow for incremental bounds algorithm.
As in the TravelBike, the CargoBike has two numeric features totalVolume and requestedVolume where the former is computed by summing up the volume of all bags and the latter specifies a minimum for the former (computed) value. However, different from before, the feature bags has cardinality 0..*, which stands for zero or more bags and is unbounded above. This can not be solved natively with the encoding presented in Section 4.2.
As a simple workaround, we set a maximum bound during the refinement phase and check whether this leads to a solution. The CoomSuite currently offers two search strategies to determine this maximum bound: A linear and an exponential one (Francescutto et al. Reference Francescutto, Schekotihin and El-Kholany2021). We call this approach Incremental Bounds and proceed in the following manner (cf. Figure 3):
-
1. Parse the Coom model into the serialized ASP fact format.
-
2. Set the initial maximum upper bound to
$n$
(typically
$n=1$
). -
3. Refine and solve the configuration problem.
-
4. If no solution is found, determine a new maximum bound according to the chosen strategy and repeat from step 3.
While the linear search strategy simply increases the maximum bound by a chosen value
$k$
(typically
$k=1$
), the exponential one is inspired by Francescutto et al. (Reference Francescutto, Schekotihin and El-Kholany2021) and first doubles the current bound until finding a solution and then converges to the optimal bound.
While this approach is very simple, its advantages are that it is general (works with any combination of open cardinalities) and does not require any changes to the ASP encoding. Further, at least in an approximate way, it provides a built-in minimization on the number of parts. However, it does not (yet) make use of clingo’s multi-shot solving capabilities, and therefore grounding has to performed again on every iteration.
To solve a Coom instance with incremental bounds, we can use the –bounds option to specify the desired search strategy as shown in Listing 21. Here, we have chosen linear search and set the value of requestedVolume to
$60$
via a user input file. As the maximum volume of a single bag is
$20$
, the iteration is not able to find a solution until the maximum bound is set to
$3$
.
Solving the CargoBike example with the incremental bounds option
5 Solving Coom interactively
While in the previous sections the workflow assumed an input from the user only at the beginning of the process, in practice, users typically want to interact with the system continuously, for example to experiment with different settings, explore the solution space or just to debug the configuration model. This is especially true for complex configuration problems where the number of solutions is large and difficult to envision by just looking at an input model (whether in textual or graphical form). In that sense, a user interface (UI) for solving Coom interactively is a valuable addition to the CoomSuite workbench.
For that purpose, we next present a prototypical UI which is generated and driven by ASP, more precisely by the clinguin system (Beiser et al. Reference Beiser, Hahn and Schaub2024). This system uses a simple design with dedicated predicates to define a UI and the behavior of user-triggered events, thereby greatly facilitating the specification of continuous user interactions with an ASP system. For details about the syntax and functionality of clinguin we refer the reader to (Beiser et al. Reference Beiser, Hahn and Schaub2024).
The UI presented in this section uses the Coom[x] encoding presented in Section 4.2 plus an additional clinguin encoding defining its layout, style and functionality. Since integration with constraint systems such as flingo is currently limited in clinguin, the UI only works with clingo.
User input as introduced in Section 4.4 is no longer needed. Instead, the user can interactively make choices to create a configuration solution. For this, we use assumptions, which can be interpreted as integrity constraints that force the encoding to entail the provided atom. As before with the user input, these assumptions can be used to set values to attributes or to force the inclusion of a part in the final configuration. Moreover, the UI provides additional functionality for the user to browse solutions, download the current Coom solution and obtain basic explanations of why a selection is not valid.
We start by showcasing a simple interaction of the UI using the TravelBike example by presenting snippets of the UI encoding together with screenshots of the possible user interactions. The full UI encoding can be found in (Baumeister et al. Reference Baumeister, Herud, Ostrowski, Reutelshöfer, Rühling, Schaub and Wanko2025a). Then, we proceed to show the explanation features of the UI and how they are implemented in clinguin.
Furthermore, to better demonstrate the UI capabilities, we do not use the simplified version of the TravelBike from above but instead use the complete example. The main differences are that the Wheel and Bag enumerations additionally have a weight attribute contributing to the totalWeight of the bike and which can be constrained by a user-set value maxWeight. There are also additional feature[s] such as the color of the bike and the material of the Bag. Lastly, the TravelBike contains some additional constraints among which we only highlight the conditional requirement in Listing 22 stating that the color Red implies a frontWheel of size 20.
Conditional requirement of the complete TravelBike example
Initial state of UI.
Attributes and values Figure 4 displays the initial state of the UI upon loading with an opened dropdown menu showing the available options for the color of the bike. Upon selecting Red as the color, the UI updates to show any inferred values resulting from this choice. In this case, the constraint from Listing 22 causes a frontWheel of size 20 to be inferred and this is updated accordingly in the UI (cf. Figure 5).
UI after selecting the color red.
We now explain how this is represented in the clinguin encoding. For the sake of brevity, we only show exemplary snippets of the encoding relevant to attributes and values. Note that while the UI is built to represent the Coom input language, the encoding is using the predicates (and naming conventions) of the ASP fact format (cf. Section 4.2).
Definition of included attributes and their values in the UI
The first two Lines of Listing 23 create auxiliary predicates for the two types of attributes in our fact format. Subsequently, these are used in Lines 3 and 4 to create the predicate i_attr(X,AT) stating that attribute variable
$X$
of type
$AT$
is included (in the solution).
Here, Line 3 checks whether an attribute variable is included in all solutions using the dedicated clinguin predicate _all/1. This allows us to show only relevant attributes in the UI. In the two screenshots, for instance, we do not see any attributes for the possible bag[s] as they are not included in all solutions (thus not mandatory). Line 4, on the other hand, checks what attribute variables are included while browsing through solutions. Similarly, Lines 5 and 6 define the (attribute) values to be shown via predicate i_value(X,V).
With these auxiliary predicates, the first rule in Listing 24 creates a dropdown menu on the UI for each attribute, and the second rule adds the text for this dropdown menu when a value exists. We can see this when comparing the first and second screenshot in Figures 4 and 5 where the text in the dropdown menus of the color and frontWheel enumerations changes accordingly.
Definition of UI dropdown menus
The style of the dropdown menus is defined in Listing 25 where the first two rules set the style for inferred values. The first rules add the light text with low opacity for values that are inferred but not (yet) selected, for example as for the frontWheel. Furthermore, the second rule removes the border of the dropdown menus of such attributes to better distinguish them.
Next, the third and fourth rule add the class "btn-secondary", which is the purple button style, for mandatory discrete attributes (stemming from enumerations in Coom) for which either a value has been selected or there are multiple options left. Note that for numeric values (not shown here) this works similarly but with the class "btn-primary", which is the blue button style. Selecting values in clinguin is done via adding assumptions to clingo for the corresponding atom and the predicate _clinguin_assume/2 is added by clinguin for every atom that has been assumed to be true or false.
Definition of UI style for attributes
The rules in Listing 26 are responsible for providing the options of the dropdown menus that are still valid. The first rule creates an auxiliary predicate with all possible values which is subsequently used in the last three rules to create one dropdown menu item for each such value.
Definition of possible values for UI dropdown menus
Upon clicking on one of these values, a call is made to the solver to add the assumption of the corresponding value assignment, thus forcing the entailment of the given value and restricting the possible solutions (cf. Line 6). The dedicated clinguin predicate _any/1 is the counterpart for _all/1 and specifies that an atom is contained in at least one stable model.
Explanations The two cropped screenshots in Figure 6 show the explanation features of the UI. Recall the constraint in Listing 22 stating that the color Red implies a frontWheel of size 20 (which belongs to option W20) and that the UI inferred the latter value upon selecting Red as the color. Accordingly, when we open the dropdown menu of the frontWheel, we see the other (invalid) options in red but it is still possible to click on them. When selecting an invalid value, however, the affected values of the frontWheel and the color turn red and the UI shows an explanation of why the newly selected value is not valid. We now explain how this works inside clinguin.
Our approach to explanations for invalid values follows (Beiser et al. Reference Beiser, Hahn and Schaub2024). In a nutshell, this means that we use a specialized clinguin backend which provides a minimal unsatisfiable set (MUS) of assumptions whenever the encoding is unsatisfiable. In this way, we allow the user to select invalid values, and thus to let the problem become unsatisfiable, while subsequently using the information about faulty assumptions to highlight previously selected values in red. For our approach, this has the limitation that it only works for invalid selections of attribute values but not for the inclusion of an invalid part.
Additionally, we leverage the definition of constraints in the refined ASP instance to provide the user with a natural language explanation of why a certain value is invalid. To do this, we indicate to the explanation backend that the atoms of predicate constraint/2 should be treated as assumptions, and thus be included as part of the reasons for unsatifiablity. Moreover, we extend the ASP fact format for the configuration to include the predicate explanation/2 to store natural language explanations for Boolean constraints. For instance, the constraint !root.color[0] = Red||root.frontWheel[0].size[0] = 20 has a natural language explanation: “If the color is red, then the size of the front wheel should be 20.”
Thanks to the generality of Boolean operators, we were able to automatically generate these explanations for all Boolean constraints using a Large Language Model (LLM) by prompting it with two simple examples. However, they can also be provided by the user. In fact, Coom offers a dedicated keyword for this which we plan to integrate in the workflow of the CoomSuite in the future. While it is desirable to have these kinds of explanations for all constraints, we limit ourselves to Boolean constraints for now and leave explanations for table constraints as future work as their treatment is more complex.
A snippet of the corresponding UI encoding is shown in Listing 27.
UI explanation encoding
The first rule sets the red text style for the invalid dropdown menu items which belong to domain values not contained in any solution. The other three rules are utilizing the dedicated clinguin predicate _clinguin_mus/1 which provides information about the MUS. While the first rule sets the red button style for all values contained in the MUS, the second and third rule provide the (natural language) explanation inside a separate window (cf. Figure 6).
Explanations in the UI after selecting an invalid value.
Finally, leaving behind the topic of explanations, the last screenshot shows the addition of a bag to the configuration (cf. Figure 7) by means of clicking on the small icon containing a
$+$
. Since it was optional to add this part, it includes a red button to remove it. For the sake of brevity, we do not go into further detail here. As next steps, the user might decide to browse the different solutions, pick one and continue modifying it, or download it in the format of a Coom solution. The interested reader can try this out by following the instructions in (Baumeister et al. Reference Baumeister, Herud, Ostrowski, Reutelshöfer, Rühling, Schaub and Wanko2025a). Currently, this requires running clinguin separately but for future versions of the CoomSuite a direct integration is planned.
6 The CoomSuite Workbench
The CoomSuite (Baumeister et al. Reference Baumeister, Herud, Ostrowski, Reutelshöfer, Rühling, Schaub and Wanko2025a) is intended to serve as a workbench for experimentation with industrial-scale product configuration problems. While the included benchmark collection can be utilized with other paradigms, its current infrastructure is primarily geared towards ASP. Specifically, the CoomSuite is available as a Python package, installable via pip. It includes a (customizable) ANTLR v4 parser to convert Coom specifications into facts, along with an ASP encoding to harmonize the fact format with the chosen configuration encoding. The current distribution includes four scalable benchmark series, a single ASP encoding covering all essential configuration concepts needed for the three Coom language fragments, as well as an additional one for the hybrid solver flingo (Cabalar et al. Reference Cabalar, Fandinno, Schaub and Wanko2025).
Adding a bag to the solution.
Benchmark sets of the CoomSuite
For each of the three Coom language fragments, we include a benchmark set in the CoomSuite detailed in Table 1. The two language extensions Coom[p*] and Coom[x*] currently have no dedicated benchmark sets. Additionally, the CoomSuite includes the benchmark set of a Restaurant corresponding to the Coom[x] language, however, with much simpler numerical calculations. Here, the aim is to configure the assignment of a given number of chairs to tables of different sizes. It makes use of partonomy as well as simple numeric constraints and the scalable factor is the total number of chairs needed. We decided to not show the results of the Restaurant domain here, as they were similar to the Core and CityBikeFleet domains.
Runtimes for benchmarks of Table 1.
To provide a glimpse into the usage of the CoomSuite, we conducted sample benchmarks comparing the standard ASP encoding (Section 4.2.2) with that designed for flingo (Section 4.3), which utilizes integer variables. We ran all instances of the benchmarks in Table 1 on a compute cluster with Intel Xeon E5-2650v4@2.9 GHz CPUs with 64 GB of memory running Debian Linux 10.Footnote 5 We used a timeout of 300 s and limited the memory to 16 GB per instance. Figure 8 shows the runtimes of finding one stable model for both solvers clingo and flingo. On the two non-numeric domains (Core and CityBikeFleet) clingo performs better than flingo. While clingo is able to solve most instances within a couple seconds (and takes up to 60 s for bigger instances), flingo times out on some of the instances of the Core domain. In general the runtimes of flingo are about one order of magnitude higher than those of clingo. However, for the TravelBikeFleet, flingo clearly outperforms clingo due to the problem of the latter with large numeric ranges. In contrast, flingo can handle these effortlessly due to its native handling of integer variables. Note that when clingo times out it is usually during grounding, while for flingo this usually happens during its internal preprocessing which uses clingo’s Python API.
7 Discussion
Researchers often lack access to industrial-scale examples to evaluate their work due to confidentiality or limited public availability. To address this challenge in product configuration, we introduce the CoomSuite, a workbench offering a curated collection of product model benchmarks and tools for converting them to ASP. These benchmarks, derived from industrial contexts, reflect the key challenges of product configuration. The workflow includes a refinement step that separates the ASP representation of the Coom input from the representation tailored to specific ASP encodings or systems. We highlighted the design of a series of such ASP encodings that handle increasingly complex Coom models.
Our work provides not only the first publicly available ASP implementation of Coom but also (indirectly) establishes first semantic underpinnings for Coom. However, this is just the starting point. Future challenges include addressing unimplemented Coom features such as optimization and explanations, as well applying and further developing alternative ASP configuration encodings (Falkner et al. Reference Falkner, Ryabokon, Schenner and Shchekotykhin2015; Gençay et al. Reference Gençay, Schüller and Erdem2019; Rühling et al. Reference Rühling, Schaub and Stolzmann2023) within this uniform industrial-scale setting. Concrete improvements include a normalization of constraints during parsing which enables the reutilization of information during solving, studying a more native representation of Coom for flingo, and the development of a truly incremental approach for unbounded cardinalities using clingo’s multi-shot solving capabilities. While the current approach to the latter provides a simple and general baseline solution, a multi-shot approach will most likely provide a much better performance. However, this requires greater modifications to the ASP encoding and further study on how to handle multiple, especially nested, open cardinalities effectively as well as an extension of the benchmark sets for the sake of an exhaustive evaluation.
As what concerns transparency and user integration, we can leverage ASP-driven visualization (Hahn et al. Reference Hahn, Sabuncu, Schaub and Stolzmann2022) and enhance the capabilities for interactive exploration of the configuration space by means of further conceptual and technical development of the UI.
We also aim to expand the model benchmarks in the CoomSuite with more domains inspired by real-world applications, creating a comprehensive and challenging workbench for advancing ASP development and beyond.
Open access
