💻 computer science

Towards Industrial-scale Product Configuration

This paper introduces the COOM Suite, a comprehensive collection of product configuration benchmarks and bike model examples formulated in the COOM language, alongside an adaptable ASP-based workflow, to address the challenges of industrial-scale product configuration and provide a common ground for stakeholders.

Original authors: Joachim Baumeister (denkbares, Würzburg, Germany, University of Würzburg, Germany), Susana Hahn (University of Potsdam, Germany, Potassco Solutions, Germany), Konstantin Herud (denkbares, Würzburg, Ge

Published 2026-03-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Joachim Baumeister (denkbares, Würzburg, Germany, University of Würzburg, Germany), Susana Hahn (University of Potsdam, Germany, Potassco Solutions, Germany), Konstantin Herud (denkbares, Würzburg, Germany), Max Ostrowski (Potassco Solutions, Germany), Jochen Reutelshöfer (denkbares, Würzburg, Germany), Nicolas Rühling (University of Potsdam, Germany, UP Transfer, Germany), Torsten Schaub (University of Potsdam, Germany, Potassco Solutions, Germany), Philipp Wanko (Potassco Solutions, Germany)

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are walking into a massive, high-tech bicycle shop. You want to build the perfect bike, but the options are overwhelming. You can choose the color, the wheel size, the type of frame, and how many storage bags you need. But there are rules: if you pick a bright yellow color, you can't have tiny wheels; if you want to carry heavy cargo, you need a specific frame; and if you ask for 100 liters of storage, you can't just have one tiny bag.

This is the world of Product Configuration. It's the digital engine behind customizing everything from cars to computers. But building the "brain" that knows all these rules and can instantly tell you what works and what doesn't is incredibly hard, especially when the rules get complex.

This paper introduces a new toolkit called CoomSuite to help engineers and researchers build these "brains" more easily. Here is the breakdown in simple terms:

1. The Problem: The "Tower of Babel" of Rules

Right now, companies use many different languages and methods to describe these product rules. It's like everyone in the shop speaking a different dialect. Researchers trying to invent new ways to solve these puzzles struggle because they can't compare their ideas against a standard set of examples. They don't have a "common playground" to test their tools.

2. The Solution: The "Coom" Language and the "Suite"

The authors created a standardized language called Coom (think of it as a universal grammar for product rules) and bundled it into a toolkit called CoomSuite.

They organized this toolkit into three levels of difficulty, like video game levels:

Level 1 (The Kids' Bike): Simple rules. "If the bike is red, the wheels must be small." This is like a basic puzzle.
Level 2 (The City Bike): Adds parts and quantities. "You can have 1 to 3 bags on the rack." This introduces the idea of counting and grouping items.
Level 3 (The Travel/Cargo Bike): The boss level. This handles math and unlimited options. "Calculate the total weight of all bags," or "You can add as many bags as you want, as long as the total weight doesn't exceed 50kg."

3. The Engine: Answer Set Programming (ASP)

How does the computer actually solve these puzzles? The paper uses a powerful logic engine called Answer Set Programming (ASP).

The Analogy: Imagine a super-smart detective (the ASP solver).

Translation: First, the CoomSuite translates the bike shop's rules (written in Coom) into a list of facts the detective understands (like "Red color exists," "Wheel size 16 exists").
Investigation: The detective tries out different combinations. "What if I pick Red and Size 16? Oh wait, the rules say that's impossible. Scratch that."
The Solution: The detective finds a valid combination (e.g., "Red, Size 20, 2 bags") and presents it back to you in a format you can read.

The paper shows that this detective can be very fast, but sometimes it gets stuck on huge math problems. To fix this, they also tested a different type of detective (a solver called flingo) that is specifically good at handling big numbers and math, proving that having different tools for different jobs is a smart move.

4. The Interactive Interface: The "Magic Mirror"

Usually, you have to type in a list of choices and wait for a result. But the authors built a User Interface (UI) that acts like a magic mirror.

Real-time Feedback: As you click "Red" on the screen, the mirror instantly grays out the tiny wheels because the rules say they don't fit.
Explaining the "Why": If you try to pick a combination that breaks the rules, the mirror doesn't just say "Error." It explains, "You can't pick Red because Red requires Size 20 wheels."
Adding Parts: You can click a "+" button to add a bag. If you add too many, the system warns you immediately.

5. The "Unbounded" Challenge

One of the coolest features is handling unbounded cardinalities. Imagine a cargo bike where you don't know how many bags you need beforehand. Maybe you need 1, maybe 100.

The Trick: The system tries a small number (say, 1 bag). If that doesn't work, it tries 2. Then 3. It keeps increasing the limit until it finds a solution. It's like a mechanic trying different sized boxes until they find the one that fits all your luggage.

Why Does This Matter?

For Companies: It makes it easier to build complex custom products without hiring a team of PhDs to write the code.
For Researchers: It gives them a standard set of "test bikes" to see if their new algorithms are actually better than the old ones.
For You: It means that in the future, configuring a complex product (like a custom computer or a specialized medical device) could be as easy and intuitive as playing a video game, with instant feedback on what works and what doesn't.

In short: This paper builds a universal translator and a playground for customizing products. It turns the chaotic, confusing world of industrial rules into a clear, interactive, and solvable puzzle.

1. Problem Statement

Product configuration is a critical challenge in modern manufacturing, where industries must meet demands for high-variance, complex products while maintaining high levels of automation. Existing approaches struggle with the diversity of modeling methods, representations, and configuration systems. A significant gap exists between the practical application tasks understood by industry stakeholders and the precise semantics of formal modeling languages. Furthermore, there is a lack of publicly accessible, representative benchmarks that allow researchers and developers to compare different configuration paradigms (e.g., Constraint Programming, SAT, Answer Set Programming) on industrial-scale problems.

2. Methodology

The authors propose a comprehensive solution centered around CoomSuite, a workbench for industrial-scale product configuration. The methodology involves three main pillars:

A. The Coom Language and Benchmarks

The authors utilize Coom, an industrial configuration language, and define three fragments of increasing complexity to serve as benchmarks:

CoomCore: Focuses on discrete attributes and basic constraint satisfaction (similar to CSP). Example: KidsBike.
Coom[p]: Extends CoomCore with partonomies (hierarchical structures) and cardinalities (quantities of parts). Example: CityBike.
Coom[x]: Adds numeric variables, arithmetic calculations, and aggregate functions (e.g., sum, count). Example: TravelBike.
Extensions (Coom[p] and Coom[x]):** Support for unbounded cardinalities (where the number of parts is not known a priori). Example: CargoBike.

B. ASP-Based Workflow

The core of the solution is an Answer Set Programming (ASP) workflow (illustrated in Figure 1 of the paper):

Parsing: A custom Python/ANTLR v4 parser converts Coom specifications and optional user inputs into a serialized set of ASP facts representing the parse tree.
Refinement: A specialized ASP visitor refines these facts into a normalized format. This step abstracts away specific syntax details, creating a unified representation of variables (parts/attributes), domains, and constraints (Boolean, table, arithmetic).
Encoding: The refined facts are fed into specific ASP encodings tailored to different solvers:
- Clingo: Uses standard ASP rules, weight constraints, and conditional literals to handle Boolean logic, table constraints, and arithmetic aggregates.
- Flingo: A hybrid solver (CASP) extension that handles conditional linear constraints with integer variables. It avoids the "grounding bottleneck" of standard ASP by treating integer variables as non-grounded theory atoms, making it superior for problems with large numeric ranges.
Output: Valid answer sets are transformed back into readable Coom solutions.

C. Interactive Configuration

The paper introduces a User Interface (UI) driven by the clinguin system. This allows for:

Interactive Selection: Users can select attributes and parts in real-time.
Inference & Propagation: The system instantly infers valid/invalid options based on constraints (e.g., selecting "Red" forces "Front Wheel Size 20").
Explanations: If a user selects an invalid value, the system uses Minimal Unsatisfiable Sets (MUS) to identify the conflicting assumptions and provides natural language explanations (generated via LLM prompting) for why a selection is invalid.

D. Handling Unbounded Cardinalities

For models with unbounded parts (e.g., an unknown number of bags), the authors propose an Incremental Bounds algorithm:

Start with a small upper bound (e.g., $n=1$ ).
Solve the problem.
If unsatisfiable, increase the bound (linearly or exponentially) and re-solve.
This approach avoids modifying the core ASP encoding, relying instead on iterative solving.

3. Key Contributions

CoomSuite: The first publicly available, curated collection of industrial-scale product configuration benchmarks formulated in a unified language (Coom). It includes scalable models (Bike fleets, CargoBikes) and resources for ASP.
Unified Workflow: A robust pipeline for converting industrial configuration models into ASP, featuring a separation between language parsing and solver-specific encoding.
Dual-Solver Approach: Demonstrates the efficacy of using both Clingo (for discrete/logic-heavy problems) and Flingo (for numeric-heavy problems) within the same framework.
Interactive UI with Explanations: A prototype UI that not only solves configurations interactively but also explains why certain configurations are invalid using MUS and natural language generation.
Semantic Foundation: The work provides the first semantic underpinnings and public ASP implementation for the Coom language.

4. Results

The authors evaluated the CoomSuite on a compute cluster using benchmarks from Table 1 (Core, CityBikeFleet, TravelBikeFleet):

Clingo vs. Flingo Performance:
- On non-numeric domains (Core, CityBikeFleet), Clingo outperformed Flingo, solving instances in seconds while Flingo occasionally timed out.
- On numeric domains (TravelBikeFleet), Flingo significantly outperformed Clingo. Clingo struggled with the grounding of large integer ranges, whereas Flingo handled them natively via theory atoms.
Scalability: The Incremental Bounds approach successfully solved CargoBike instances with unbounded cardinalities, finding solutions by iteratively increasing the search space.
Usability: The interactive UI successfully demonstrated real-time constraint propagation and the generation of human-readable explanations for invalid user inputs.

5. Significance

This paper bridges the gap between academic research in Answer Set Programming and industrial application in product configuration. By providing a standardized, open-source benchmark suite (CoomSuite), it enables:

Comparability: Researchers can now fairly compare different configuration paradigms (ASP, SAT, CP) on realistic, complex industrial problems.
Adoption: It lowers the barrier to entry for using ASP in industrial settings by providing a ready-to-use toolchain (parser, encodings, UI).
Future Research: It establishes a baseline for future work on optimization, more advanced incremental solving (using Clingo's multi-shot capabilities), and expanding the benchmark suite to other industrial domains.

In summary, the paper presents a mature, end-to-end framework for industrial product configuration that leverages the strengths of modern ASP solvers to handle complex, scalable, and interactive configuration tasks.