46 research outputs found
On the Complexity of Optimization Problems based on Compiled NNF Representations
Optimization is a key task in a number of applications. When the set of
feasible solutions under consideration is of combinatorial nature and described
in an implicit way as a set of constraints, optimization is typically NP-hard.
Fortunately, in many problems, the set of feasible solutions does not often
change and is independent from the user's request. In such cases, compiling the
set of constraints describing the set of feasible solutions during an off-line
phase makes sense, if this compilation step renders computationally easier the
generation of a non-dominated, yet feasible solution matching the user's
requirements and preferences (which are only known at the on-line step). In
this article, we focus on propositional constraints. The subsets L of the NNF
language analyzed in Darwiche and Marquis' knowledge compilation map are
considered. A number of families F of representations of objective functions
over propositional variables, including linear pseudo-Boolean functions and
more sophisticated ones, are considered. For each language L and each family F,
the complexity of generating an optimal solution when the constraints are
compiled into L and optimality is to be considered w.r.t. a function from F is
identified
Reasoning on Feature Models: Compilation-Based vs. Direct Approaches
Analyzing a Feature Model (FM) and reasoning on the corresponding
configuration space is a central task in Software Product Line (SPL)
engineering. Problems such as deciding the satisfiability of the FM and
eliminating inconsistent parts of the FM have been well resolved by translating
the FM into a conjunctive normal form (CNF) formula, and then feeding the CNF
to a SAT solver. However, this approach has some limits for other important
reasoning issues about the FM, such as counting or enumerating configurations.
Two mainstream approaches have been investigated in this direction: (i) direct
approaches, using tools based on the CNF representation of the FM at hand, or
(ii) compilation-based approaches, where the CNF representation of the FM has
first been translated into another representation for which the reasoning
queries are easier to address. Our contribution is twofold. First, we evaluate
how both approaches compare when dealing with common reasoning operations on
FM, namely counting configurations, pointing out one or several configurations,
sampling configurations, and finding optimal configurations regarding a utility
function. Our experimental results show that the compilation-based is efficient
enough to possibly compete with the direct approaches and that the cost of
translation (i.e., the compilation time) can be balanced when addressing
sufficiently many complex reasoning operations on large configuration spaces.
Second, we provide a Java-based automated reasoner that supports these
operations for both approaches, thus eliminating the burden of selecting the
appropriate tool and approach depending on the operation one wants to perform
Algebraic model counting
Weighted model counting (WMC) is a well-known inference task on knowledge bases, and the basis for some of the most efficient techniques for probabilistic inference in graphical models. We introduce algebraic model counting (AMC), a generalization of WMC to a semiring structure that provides a unified view on a range of tasks and existing results. We show that AMC generalizes many well-known tasks in a variety of domains such as probabilistic inference, soft constraints and network and database analysis. Furthermore, we investigate AMC from a knowledge compilation perspective and show that all AMC tasks can be evaluated using sd-DNNF circuits, which are strictly more succinct, and thus more efficient to evaluate, than direct representations of sets of models. We identify further characteristics of AMC instances that allow for evaluation on even more succinct circuits
Cliquewidth and knowledge compilation
In this paper we study the role of cliquewidth in succinct representation of Boolean functions. Our main statement is the following: Let Z be a Boolean circuit having cliquewidth k. Then there is another circuit Z * computing the same function as Z having treewidth at most 18kâ+â2 and which has at most 4|Z| gates where |Z| is the number of gates of Z. In this sense, cliquewidth is not more âpowerfulâ than treewidth for the purpose of representation of Boolean functions. We believe this is quite a surprising fact because it contrasts the situation with graphs where an upper bound on the treewidth implies an upper bound on the cliquewidth but not vice versa.
We demonstrate the usefulness of the new theorem for knowledge compilation. In particular, we show that a circuit Z of cliquewidth k can be compiled into a Decomposable Negation Normal Form (dnnf) of size O(918k k 2|Z|) and the same runtime. To the best of our knowledge, this is the first result on efficient knowledge compilation parameterized by cliquewidth of a Boolean circuit
On Formal Methods for Large-Scale Product Configuration
<p>In product development companies mass customization is widely used to achieve better customer satisfaction while keeping costs down. To efficiently implement mass customization, product platforms are often used. A product platform allows building a wide range of products from a set of predefined components. The process of matching these components to customers' needs is called product configuration. Not all components can be combined with each other due to restrictions of various kinds, for example, geometrical, marketing and legal reasons. Product design engineers develop configuration constraints to describe such restrictions. The number of constraints and the complexity of the relations between them are immense for complex product like a vehicle. Thus, it is both error-prone and time consuming to analyze, author and verify the constraints manually. Software tools based on formal methods can help engineers to avoid making errors when working with configuration constraints, thus design a correct product faster.</p>
<p>This thesis introduces a number of formal methods to help engineers maintain, verify and analyze product configuration constraints. These methods provide automatic verification of constraints and computational support for analyzing and refactoring constraints. The methods also allow verifying the correctness of one specific type of constraints, item usage rules, for sets of mutually-exclusive required items, and automatic verification of equivalence of different formulations of the constraints. The thesis also introduces three methods for efficient enumeration of valid partial configurations, with benchmarking of the methods on an industrial dataset.</p>
<p>Handling large-scale industrial product configuration problems demands high efficiency from the software methods. This thesis investigates a number of search-based and knowledge-compilation-based methods for working with large product configuration instances, including Boolean satisfiability solvers, binary decision diagrams and decomposable negation normal form. This thesis also proposes a novel method based on supervisory control theory for efficient reasoning about product configuration data. The methods were implemented in a tool, to investigate the applicability of the methods for handling large product configuration problems. It was found that search-based Boolean satisfiability solvers with incremental capabilities are well suited for industrial configuration problems.</p>
<p>The methods proposed in this thesis exhibit good performance on practical configuration problems, and have a potential to be implemented in industry to support product design engineers in creating and maintaining configuration constraints, and speed up the development of product platforms and new products.</p
On Computing Probabilistic Abductive Explanations
The most widely studied explainable AI (XAI) approaches are unsound. This is
the case with well-known model-agnostic explanation approaches, and it is also
the case with approaches based on saliency maps. One solution is to consider
intrinsic interpretability, which does not exhibit the drawback of unsoundness.
Unfortunately, intrinsic interpretability can display unwieldy explanation
redundancy. Formal explainability represents the alternative to these
non-rigorous approaches, with one example being PI-explanations. Unfortunately,
PI-explanations also exhibit important drawbacks, the most visible of which is
arguably their size. Recently, it has been observed that the (absolute) rigor
of PI-explanations can be traded off for a smaller explanation size, by
computing the so-called relevant sets. Given some positive {\delta}, a set S of
features is {\delta}-relevant if, when the features in S are fixed, the
probability of getting the target class exceeds {\delta}. However, even for
very simple classifiers, the complexity of computing relevant sets of features
is prohibitive, with the decision problem being NPPP-complete for circuit-based
classifiers. In contrast with earlier negative results, this paper investigates
practical approaches for computing relevant sets for a number of widely used
classifiers that include Decision Trees (DTs), Naive Bayes Classifiers (NBCs),
and several families of classifiers obtained from propositional languages.
Moreover, the paper shows that, in practice, and for these families of
classifiers, relevant sets are easy to compute. Furthermore, the experiments
confirm that succinct sets of relevant features can be obtained for the
families of classifiers considered.Comment: arXiv admin note: text overlap with arXiv:2207.04748,
arXiv:2205.0956
IASCAR: Incremental Answer Set Counting by Anytime Refinement
Answer set programming (ASP) is a popular declarative programming paradigm
with various applications. Programs can easily have many answer sets that
cannot be enumerated in practice, but counting still allows quantifying
solution spaces. If one counts under assumptions on literals, one obtains a
tool to comprehend parts of the solution space, so-called answer set
navigation. However, navigating through parts of the solution space requires
counting many times, which is expensive in theory. Knowledge compilation
compiles instances into representations on which counting works in polynomial
time. However, these techniques exist only for CNF formulas, and compiling ASP
programs into CNF formulas can introduce an exponential overhead. This paper
introduces a technique to iteratively count answer sets under assumptions on
knowledge compilations of CNFs that encode supported models. Our anytime
technique uses the inclusion-exclusion principle to improve bounds by over- and
undercounting systematically. In a preliminary empirical analysis, we
demonstrate promising results. After compiling the input (offline phase), our
approach quickly (re)counts.Comment: Under consideration in Theory and Practice of Logic Programming
(TPLP