PreprintPDF Available

IDP-Z3: a reasoning engine for FO(.)

Preprints and early-stage research may not have been peer reviewed yet.

Abstract and Figures

FO(.) (aka FO-dot) is a language that extends classical first-order logic with constructs to allow complex knowledge to be represented in a natural and elaboration-tolerant way. IDP-Z3 is a new reasoning engine for the FO(.) language: it can perform a variety of generic computational tasks using knowledge represented in FO(.). It supersedes IDP3, its predecessor, with new capabilities such as support for linear arithmetic over reals and quantification over concepts. We present four knowledge-intensive industrial use cases, and show that IDP-Z3 delivers real value to its users at low development costs: it supports interactive applications in a variety of problem domains, with a response time typically below 3 seconds.
Content may be subject to copyright.
IDP-Z3: a reasoning engine for FO(·)
Pierre Carbonnelle1,3,Simon Vandevelde2,3,4,Joost Vennekens2,3,4,Marc Denecker1,3
1KU Leuven, Dept. of Computer Science, Celestijnenlaan 200, 3001 Heverlee, Belgium
2KU Leuven, De Nayer Campus, Dept. of Computer Science,
J.-P.-De Nayerlaan 5, 2860 Sint-Katelijne-Waver, Belgium
3Leuven.AI – KU Leuven Institute for AI, B-3000, Leuven, Belgium
4Flanders Make - DTAI-FET
{pierre.carbonnelle, s.vandevelde, joost.vennekens, marc.denecker}
An important sign of intelligence is the capacity to apply a
body of knowledge to a particular situation in order to not
only derive new knowledge, but also to determine relevant
questions or provide explanations. Developing interactive
systems capable of performing such a variety of reasoning
tasks for the benefits of its users has proved difficult, no-
tably for performance and/or development cost reasons. Still,
recently, a reasoning engine, called IDP3, has been used to
build such systems, but it lacked support for arithmetic oper-
ations, seriously limiting its usefulness. We have developed a
new reasoning engine, IDP-Z3, that removes this limitation,
and we put it to the test in four knowledge-intensive industrial
use cases.
This paper describes FO(·) (aka FO-dot), the language used
to represent knowledge in the IDP3 and IDP-Z3 system. It
then describes the generic reasoning tasks that IDP-Z3 can
perform, and how we used them to build a generic user inter-
face, called the Interactive Consultant. Finally, it reports on
the four use cases.
In these four use cases, the interactive applications based on
IDP-Z3 were capable of intelligent behavior of value to users,
while having a low development cost (typically 10 days) and
an acceptable response time (typically below 3 seconds). Per-
formance could be further improved, in particular for prob-
lems on larger domains.
1 Introduction
McCarthy (1989) presents four possible levels of use of logic
in Artificial Intelligence. Intelligent machines at the first
level, such as neural networks, do not use logic sentences
at all. At the second level, machines use logic sentences
to represent facts from which they reach conclusions using
ad-hoc procedures, typically written in imperative program-
ming languages, without the generality of ordinary logical
Machines at the third level use logical deduction to reach
conclusions. He cites Prolog as one of the languages used to
program them. Such machines are rather specialized: “the
facts of one program usually cannot be used in a database
for other programs.” This is a result of their fixed deduction
strategy: because Algorithm = Logic + Control (Kowalski
1979), one has to use a new set of logic rules to create an
algorithm for a new task in the same problem domain.
By contrast, machines of the fourth and most advanced
level do not have a fixed deduction strategy. The fourth level
“involves representing general facts about the world as log-
ical sentences. [..] The facts would have the neutrality of
purpose characteristic of much human information. [..] A
key problem for achieving the fourth level is to develop a
language for a general common-sense database.”.
The IDP-Z3 system seeks to address that challenge: it is
designed so that a) one can express knowledge about pos-
sible worlds using logical sentences, and b) this knowledge
can be used for many different computational tasks. To dis-
tinguish it from inference engines at the third level, we call it
a “reasoning engine”. Reasoning engines enable the Knowl-
edge Base paradigm (Denecker and Vennekens 2008), in
which systems store declarative domain knowledge, and use
it to solve a variety of problems. This approach can sig-
nificantly reduce the development and maintenance costs of
intelligent machines (Deryck et al. 2019).
In this “System Description” paper, we present IDP-Z3
and various tools and extensions built around it. In partic-
ular, we demonstrate that IDP-Z3 allows users to leverage
their domain knowledge to produce flexible interactive sys-
tems that offer all the necessary functionality and compu-
tational performance to handle real-world problems. There
are several aspects to this:
The FO(·) language is important to allow complex knowl-
edge to be represented in a natural and elaboration-
tolerant knowledge base.
The modular and classical nature of FO(·) make it easy
to extend a KB with parts that are written in more user-
friendly notations such as DMN or Controlled Natural
The range and performance of the generic reasoning al-
gorithms offered by IDP-Z3 suffices to implement a large
class of interactive applications in an efficient way.
We present four knowledge-intensive use cases as proof
for our claims: they show that (1) real users are indeed able
to participate in the construction of the KB, (2) that IDP-
Z3 delivers significant value to these users, at low develop-
ment costs, (3) that the IDP-Z3 system, while not the most
efficient solver that exist, is able to deliver performance that
suffices to handle the real-world instances that the users want
to tackle.
arXiv:2202.00343v2 [cs.LO] 11 Feb 2022
We begin by elaborating on FO(·) and alternative for-
malisms in Section 2.1. Next, we present the IDP-Z3 en-
gine and its features in Section 3, followed by Section 4 in
which we expand on the Interactive Consultant, a generic,
user-friendly interface to solve real-world problem using the
reasoning power of IDP-Z3. As an empirical evaluation of
the system, we report on four knowledge-intensive indus-
trial use cases in Section 5, and demonstrate the benefits of
creating interactive applications using IDP-Z3. Finally, we
compare IDP-Z3 to other reasoning engines for model-based
KR languages in Section 6, and conclude in Section 7.
In short, the contributions of this paper are:
an overview of FO(·) and related formalisms;
the presentation of IDP-Z3, a new reasoning engine;
a summary of case studies involving IDP-Z3, to support
our claims;
a qualitative comparison between IDP-Z3 and other rea-
soning engines.
2 Knowledge representation
This section presents the languages used to represent knowl-
edge in IDP-Z3-based systems: FO(·) and related for-
2.1 FO(·)
FO(·) (aka FO-dot) is the Knowledge Representation lan-
guage used by the IDP-Z3 reasoning engine.
FO(·) was introduced by Denecker (2000). It is based on
first-order logic (FOL) for its constructs (,,¬,,,)
and its model semantics. FO(·) extends FOL with a few
language constructs to express complex information such as
non-inductive, inductive and recursive definitions and aggre-
gates. The syntax of the concrete logic used in IDP-Z3 is
documented online1.
A FO(·) Knowledge Base minimally consists of a vocab-
ulary and a theory. The vocabulary describes the domain-
specific ontology symbols that can be used in the theory. A
theory is a collection of assertions about possible state of
affairs. There are three classes of assertions: axioms, defini-
tions and enumerations.
A Knowledge Base written in FO(·) cannot be run: it is
just a “bag of information” formally describing models in a
problem domain. This is a consequence of the FO(·) design
goal to be task-agnostic. A corollary is that such a KB does
not distinguish inputs from outputs, and allows reasoning in
any direction.
A key advantage of the model-theoretic semantics is that
it allows reasoning with incomplete knowledge of the state
of affairs. When not much is known, many states of affairs
are possible, and the theory has many models representing
them. As more information is obtained, the set of models is
reduced. This reduced set of models can be used to perform
various forms of reasoning, e.g., to derive the consequences
of what is known, or to find the model that maximizes a
utility function.
As a very simple example, consider the voting law that
states: “You have to vote in an election if you are at least
18 year old at election time (otherwise you can not)”. The
formula in FO(·) is:
vote() 18 age().
If the age is known, the obligation to vote can be inferred;
if the obligation to vote is known to be true instead, the age
is known to be 18 or more, in any model. Furthermore, one
can also find a lower bound of the age of a person, as soon
as their obligation to vote is known.
We highlight the main features of FO(·) below.
Types Besides boolean, integer and real types, FO(·) al-
lows the creation of custom types, e.g., Person. Predicates
and functions are declared in the vocabulary, with a type sig-
nature, e.g., weight: Person Real. In the quantified
formula x in T: p(x),xranges over the extension of
type T. Types are used to syntactically verify that formu-
lae are well-typed, helping detect common errors. Types are
also called “sorts” (Wang 1952) in the literature.
Axioms The first class of assertions in a FO(·) theory is
the class of axioms. Axioms are logic sentences that are true
in any possible state of affairs.
The voting law above is an example of axiom. A voting
law that does not make voting mandatory can be expressed
in another axiom using material implication:
vote() 18 age().
(Notice that the voting obligations and permissions are rep-
resented without any modal operator, unlike formulations in
deontic logic (Von Wright 1951).)
(Inductive) definitions The second class of assertions in
FO(·) is the class of (possibly inductive) definitions. Def-
initions are very useful forms of knowledge: they specify
a unique interpretation of the defined symbol, given an in-
terpretation of its parameters. For example, the transitive
closure of a graph is uniquely defined for every graph.
It is well known that FOL cannot represent inductive def-
initions such as the transitive closure of a graph. By con-
trast, FO(·) can represent such definitions using an extension
of FOL for inductive definitions, called FO(ID) (Denecker
2000). (Inductive) definitions in FO(ID) define a defined
predicate Pin terms of the parameters of its definition by
specifying an iterative process to construct the interpretation
of Pfrom the interpretation of its parameters. However,
consistent with the model-based approach, such definitions
allow reasoning with any partial knowledge, in any direc-
tion. For example, it allows finding all the graphs that have
a given transitive closure.
Definitions are often formulated in natural languages as a
set of “rules” specifying necessary and sufficient conditions
for the definiendum to hold. FO(·) definitions are also of
this form, as illustrated in Listing 1. The definiens, i.e., the
body of a rule, can be any FOL formula. The formalism of
definitions in FO(·) is elaboration tolerant in the sense that
one can easily add a rule to a definition.
Listing 1: Multi-rule definition
{can_drive() has_license() age() 85.
can_drive() has_license() tested().
Because rules are part of definitions in FO(·), the head of a
rule must be a single atom (in contrast to ASP which allows
a disjunction in the head of so-called choice rules). Unlike
in default logic (Reiter 1980), exceptions to a rule must be
explicitly stated in the rule (possibly in the form of a pred-
icate defined separately). Unlike in defeasible logic (Nute
2001), rules do not have any priority ordering.
Data theory FOL is not well suited to express simple data
about a concrete state of affairs. Unique Names (UNA),
Domain Closure (DCA), and Completion (CA) Axioms are
needed, but stating them explicitly is cumbersome. For ex-
ample, the UNA consists of a number of axioms quadratic
in the number of constant symbols.
To address this issue, FO(·) offers a third class of asser-
tions, called enumerations, that specify the set of identifiers
interpreting a type (under UNA and DCA), and the sets and
functions interpreting predicate and function symbols (under
DCA and CA). For example, Person := {Bob, Alice
}and weight := {Bob 80, Alice 80} specify
the interpretation of type Person and function weight.
A collection of enumerations is called a structure in
FO(·). A structure is a particular type of theory: a “data”
Arithmetic FO(·) supports formulae with the 4 arithmetic
operations on integers and reals (addition, substraction, mul-
tiplication and division), as well as the comparison operators
(equality, disequality and inequalities). It does not support
transcendental functions (log,exp,sin,cos,..).
Cardinality and Aggregates The number of elements of
type T that satisfy a property pis formulated in FO(·) as:
#{el T: p(t)}
Similarly, sum(lambda x in T: f(x)) denotes the
sum of f(x) for each xin T. The minimum and maximum
aggregates are denoted min,max. Cardinality and aggregate
expressions can occur in axioms and in the body of rules.
Concept as a type Sometimes, it is necessary to reason
about the concepts in an ontology. Informally, the concept
behind an ontology symbol is its informal meaning. FO(·)
introduces the type Concept (whose extension is the set of
concepts in the ontology of the problem domain), and the
$” operator that maps a concept to its interpretation (Car-
bonnelle et al. 2022). For example, one might want to count
the number of symptoms that a person phas. This can be
formulated as:
#{x Concept[PersonBool]:
Symptom(x) $(x)(p)}
2[18.5..25) Normal
3[25..30) Overweight
430 Obese
Figure 1: DMN tables express knowledge in a user-friendly way.
This eliminates the need to reify the Symptom predicates, a
technique that is not elaboration tolerant (McCarthy 1998)
because it requires rewriting every formula involving symp-
2.2 Related formalisms
Although FO(·) uses common mathematical notations, it is
typically only usable by trained knowledge engineers. Sev-
eral approaches have been developed to allow domain ex-
perts without such background to build their own KB, when
the full power of FO(·) is not required. Knowledge in the
simpler formalisms is then converted to FO(·) to allow rea-
soning using IDP-Z3.
Decision Model and Notation and cDMN The Decision
Model and Notation (DMN) standard (Object Modelling
Group 2021) is a notation for decision logic. Its goal is to
be user-friendly, readable for everyone involved in the de-
cision process (e.g., business people, IT experts, . . .), and
In DMN, all logic is contained in decision tables: these
represent an input-output relation between the input vari-
ables (left, in green) and the output variables (right, in blue).
As an example, consider the table shown in Fig. 1, which de-
fines a patient’s BMILevel based on their BMI value. Each
row of the table expresses a decision rule, which fires if the
value of the input variable(s) matches the condition in the
input cell(s).
In (Dasseville et al. 2016), decision tables were used as
a way to represent the knowledge in a FO(·) KB. Indeed,
decision tables can be seen as syntactic sugar for FO(·), al-
lowing a user-friendly representation of definitions. For ex-
ample, the decision table shown in Fig. 1 can be translated
into FO(·) as follows:
{ BMILevel() = Underweight BMI() < 18.5.
BMILevel() = Normal 18.5 BMI() < 25.
... }
This approach was further explored by Deryck et al.
(2018) to formalize knowledge together with a domain ex-
pert. Vandevelde and Vennekens (2020) present a tool capa-
ble of, among other things, automatically translating DMN
into FO(·), thus further increasing the user-friendliness of
DMN as an alternative modeling language for FO(·).
One downside of this approach however, is the limited ex-
pressiveness of decision tables. While sufficient for typical
decision modeling, DMN is ill suited to express more com-
plex problems. As an attempt to overcome this issue, Vande-
velde, Aerts, and Vennekens (2021) present Constraint De-
cision Model and Notation (cDMN), which extends DMN
with the ability to express constraints and related concepts,
such as types, quantification, and more, while retaining the
user-friendly tabular format. cDMN tables are also translat-
able to FO(·).
Controlled Natural Language Computational seman-
tics (Blackburn and Bos 2003) studies the translation of
expressions in natural language into formal representations
that allow reasoning. Often, a subset of natural language is
considered, with a limited lexicon and grammar.
Claes et al. (2019) use this approach to build ZebraTutor, a
semi-automated tool that solves logic grid puzzles given the
clues in a simple natural language. The clues are translated
to FO(·) using a typed version of the semantical framework
of Blackburn and Bos (2006).
The “Intelli-Select” use case, described in more detail in
Section 5.3, is another example of this approach. Here, a
tree-based grammar is created in advance to define the valid
CNL sentences. An ad-hoc mechanism is used to translate
paths to FO(·) sentences.
3 IDP-Z3
IDP-Z3 is a reasoning engine that can perform a variety of
reasoning tasks on knowledge bases in the FO(·) language.
IDP-Z3 is the successor of IDP3 (De Cat, Jansen, and
Janssens 2013), another reasoning engine for FO(·). IDP3
used a custom SAT solver, called minisat(ID) (De Cat, Bo-
gaerts, and Denecker 2014): hence, its support for arithmetic
was limited. By contrast, IDP-Z3 uses an off-the-shelf SMT
solver, Z3 (De Moura and Bjørner 2008), which supports
reasoning over linear arithmetic.
FOLASP (Van Dessel, Devriendt, and Vennekens 2021)
is another reasoning engine for FO(·). It uses ASP-Core-2
solvers as back-end. Its reasoning capabilities are limited to
one reasoning task, however: model expansion.
IDP-Z3 can be run at the command line, or integrated in a
Python application as a Python package downloadable from
pypi2. Computations can also be run online via a webIDE3.
It is open source4under the LGPL 3 license.
A challenge in writing IDP-Z3 was to re-implement the
custom functionality of minisat(ID) around Z3. In partic-
ular, minisat(ID) used custom procedures to handle induc-
tive definitions. In IDP-Z3, inductive definitions are reduced
to formulae acceptable by Z3, using level mapping, as ex-
plained in (Pelov and Ternovska 2005). Another challenge
was the re-implementation of a custom procedure to deter-
mine relevance (Jansen et al. 2016).
The following generic computations are supported by
Model checking Verifies that a theory is satisfiable, i.e.,
that it has at least one model.
Model expansion Takes a theory T and a partial structure
S, and computes a model of T that expands S, if one exists.
Propagation Takes a theory T and a partial structure S,
and computes all their logical consequences, i.e., all the
ground literals that are true in every model expansion of T
and S.
This computation is also called “backbone computation”
in the literature (e.g., (Zhang, Pu, and Zhang 2019)).
Explanation Takes a theory T, a partial structure S and
a literal L obtained by propagation, and computes an ex-
planation for L in the form of a minimal set of axioms in
TS∪ {¬L}that is inconsistent. This computation is also
called “unsat core” in the literature (Barrett et al. 2009).
To create explanations more interpretable by a person,
Bogaerts et al. (2020) use IDP3 to find step-wise explana-
tions. This method has not yet been ported to IDP-Z3.
Optimisation Takes a theory T, a partial structure S and a
term, and computes the minimal value of the term in the set
of all model expansions of T and S.
Relevance Takes a theory T and a partial structure S, and
determines the atoms that are irrelevant (or “do-not-care”)
in the sense that, if one of their value were changed in any
model M of T expanding S, the resulting M’ structure would
still be a model of T.
Relevance is determined by simplifying theory T by all
the consequences of T and S, using the laws of logic. The
atoms that do not occur in the resulting formula are irrele-
vant. Indeed, changing their values cannot affect the satis-
faction of the theory.
Other reasoning tasks While not natively supported in
IDP-Z3, other reasoning tasks can be developed around IDP-
Z3. For example, one could compare two FO(·) formula-
tions, and show models where they differ, as in the Intelli-
Select use case described in Section 5.3. One could also
verify the completeness of definitions (or of DMN tables),
or generate test cases for a KB.
4 Interactive Consultant
IDP-Z3 comes with a demo web application, called the In-
teractive Consultant (Carbonnelle et al. 2019), that helps
users make decision in accordance with an FO(·) knowledge
base, using the reasoning abilities of IDP-Z3. It is the suc-
cessor of AutoConfig (Dasseville et al. 2016), which was
based on IDP3. The Interactive Consultant is used in three
of the four case studies described in the next section. It
is generic in the sense that it can be reconfigured by sim-
ply changing the FO(·) knowledge base. The user interface
is automatically generated based on the vocabulary of the
knowledge base: this helps reduce the cost of developing ap-
plications significantly (Deryck et al. 2019). It is available
Figure 2: The Interactive Consultant asks relevant questions to its user, from which it draws conclusions that it can explain.
The Interactive Consultant (IC) allows the user to enter
data in any order. This data is stored in a data theory that
is combined with the knowledge base for reasoning. The
IC enables a safe exploration of the decision search space,
without the possibility of making decisions leading to dead
ends. This is achieved by continuously computing the con-
sequences of the data theory, using propagation. If the user
is unsure why the IC propagated a specific choice, they can
ask for an explanation. Additionally, while the user fills in
what they know, the interface determines which parameters
remain relevant, avoiding unnecessary work for the user.
After having input all values that they deem necessary, the
user can ask the IC to show the optimal decision according
to what is known, using optimization.
The response time of the system after the user asserts or
retracts a fact depends on the speed of the propagation rea-
soning task. Propagation is often performed by iterative sat-
isfiability testing (Janota, Lynce, and Marques-Silva 2015),
i.e., by checking every ground atom to see if it is a conse-
quence of the theory and user input, i.e., if it has only one
possible interpretation. We improve speed of propagation in
the Interactive Consultant by reducing the number of ground
atoms to consider:
When new facts are asserted by the user, previously prop-
agated atoms do not need to be considered again: indeed,
they will remain consequences of the theory and user in-
When facts are retracted by the user, atoms that were not
consequences of the theory and user input already will
still not be, and do not need to be considered again.
Because decisions are made by a user in a context, it is of-
ten important to separate the ontology describing the context
from the one describing the decision and its consequences:
while the user has control over his decision, they do not have
control over their context. The inferences described in Sec-
tion 3 have been adapted to accommodate this split ontol-
ogy (Carbonnelle et al. 2020).
5 Case studies
In this subsection, we summarise four previously published
case studies that use IDP-Z3 as a reasoning engine.
5.1 Machine Component Designer
Aerts, Deryck, and Vennekens (2022) describe the creation
of an IDP-based knowledge base system for the design of
machine components, implemented in collaboration with a
multinational company. This company employs engineers
worldwide to conceive “design-to-order” components. Be-
fore the collaboration, each engineer followed their own ad
hoc design process, mostly based on their own experience
and preferences. This approach has multiple downsides: (a)
designing a component consumes a large amount of time,
(b) engineers may choose sub-optimal designs, and (c) if a
senior engineer leaves, a great deal of knowledge is lost by
the company.
To overcome these issues, the design knowledge was for-
malized through a series of knowledge extraction work-
shops. In such a workshop, both knowledge engineers and
domain experts are involved in modeling the knowledge
used when designing machine components. Each workshop
spanned a few days, and was performed in geologically dif-
ferent branches of the company, to ensure diversity in the
Initially, the DMN standard was used to create a model of
the experts’ knowledge. While DMN was found to be intu-
itive, it was unable to represent all knowledge in a straight-
forward manner. Indeed, DMN is well suited for rule-based,
hierarchical decision procedures with one unique output, but
it is not suitable for reasoning when several choices are pos-
sible. For example, to find the optimal design of the com-
ponent, the user had to make tentative design choices, de-
termine the resulting cost, backtrack, and subsequently con-
sider alternative designs.
In FO(·) parlance, we would say that DMN can represent
definitions, but not axioms. Axioms are used to exclude
designs that are not feasible. To allow the addition of ax-
ioms on top of the rule-based logic, the DMN model was
converted into an FO(·) KB. Additionally, some preferences
were added: e.g., “always use the cheapest material possi-
ble.” Using a weighted sum, these preferences can then be
used to automatically determine the optimal design for any
given circumstances.
In total, the KB contains 10 parameters describing 60 dif-
ferent materials (such as a maximum temperature of steel)
and 27 parameters for 31 components (such as torque and
maximum pressure).
The Interactive Consultant (described in the previous sec-
tion) is used to allow interaction with the KB. It is config-
ured for this application by simply changing the FO(·) KB.
Besides the standard interactions, the interface was further
extended to fit the company’s specific needs. Examples of
such extensions are a functionality to compare two designs,
an extended version of explanations in which not only the
set of choices are shown but also the underlying constraints
(which has since been added to the IC), a way to deacti-
vate and reactivate certain axioms, and an integration with a
Machine Learning algorithm that suggests designs based on
historic data.
Overall, the company and its engineers are very positive
about the tool. Besides a reported daily time-save of up to
30 minutes for each engineer, they report other benefits to its
usage. First and foremost, it leads to more “first-time right”
designs, which lowers production time and cost. Secondly,
for new engineers the tool serves as an excellent learning
tool, allowing them to indirectly learn from the knowledge
of the more experienced engineers. For more experienced
engineers on the other hand, the tool is used to challenge
their assumptions: when in doubt, they can swiftly verify if
their initial ideas are correct. Lastly, with their knowledge
captured in a KB, engineers leaving will not result in loss of
knowledge for the company.
The functionality of the original IDP3-based tool was
somewhat limited because IDP3 is not able to perform float-
ing point calculations. To overcome this, it has recently been
ported over into IDP-Z3, to benefit from its support of arith-
5.2 Adhesive Selection Tool
Together with the Flanders Make Joining & Materials Lab
we have been working on a case study concerning adhesive
selection (Jordens et al. 2021).
In industry, the usage of glues is rising in popularity due
to their favorable characteristics. However, besides some su-
perficial, vendor-locked websites, there is no tooling avail-
able to support selecting the right adhesive for the right
use case. Adhesives come in a wide range of options,
categorised into 18 different adhesive families, with none
suitable for all applications. The selection of an adhesive
is based on which substrates are used (e.g., steel, wood,
plastics, . . .) and on bond requirements such as minimum
strength, maximum elongation, operating temperature range
and more.
To begin, we held multiple knowledge workshops in or-
der to create a KB. Instead of using DMN to create the ini-
tial model, as in the previous case, we used cDMN due to
the constraint-heavy nature of the problem domain. In total,
we identified and formalised 21 adhesive parameters (such
as bond strength, adhesion and temperature range) and 11
substrate parameters (such as solvent resistance, maximum
temperature and magnetic type). The current version of the
KB contains 55 individual adhesives, and 31 substrates.
An interesting aspect of this case is how missing data is
handled: if a parameter value is not known (because it was,
e.g., not listed in the adhesive’s data sheet), the tool assumes
the value of the adhesive’s family. In this way, the tool uses
a reasonable estimate of the real value, similar to what the
experts do. However, if the family’s value is also unknown,
the tool warns the user that the value is unknown and it does
not apply any constraints to that parameter, instead asking
the expert to verify it manually.
The adhesive experts interact with the KB through the In-
teractive Consultant, allowing them to benefit from all of
its features. In particular, it allows reasoning in any direc-
tion. While generally, the goal is to select an adhesive, in
other cases, the adhesive is known, as well as one of the
substrates, and the goal is to find a suitable second substrate.
This “substrate selection” task is performed without modi-
fying the KB in any way.
Overall, the first impressions by the experts are positive.
In an initial test, the tool has reduced the selection process
from 3 hours to 5 minutes for one especially difficult case.
While it seemed that the tool would be most useful for newer
members of the J&ML lab, the most experienced member
has indicated that they can also benefit from it. Indeed, this
member typically chooses from a (limited) set of adhesives
of which they know most properties by heart. Using the
tool, they can find out if there are any other adhesives which
might be better suited for a job.
5.3 Intelli-Select
Deryck et al. (2021) present their work on Intelli-Select6, a
tool created for international financial institutions to support
investment management. This tool combines Constrained
Natural Language (CNL) and the IDP-Z3 system, to offer
a user-friendly way for a customer to define his investment
profile. An investment profile is a set of rules that spec-
ify the financial assets that they consider eligible for invest-
ment. This investment profile is created in CNL, and later
converted to FO(·) for processing.
For example, a user can construct the CNL sentence “Eq-
uities issued in Germany are eligible” to allow all German
equities. Additionally, a free-form Natural Language (NL)
interface is also available, which suggests CNL equivalents.
Here, an NL sentence such as “I would like to invest in Ger-
man equities” would be translated into the CNL statement
shown earlier.
To create the KB, the CNL statements are represented in
FO(·) in the form of two definitions: one for eligibility, and
one for ineligibility. In the application, the IDP-Z3 system
is then used to perform several reasoning tasks. Firstly, each
time a user adds new (in)eligibility rules, the system per-
forms propagation to show the effect of the new rules. If a
rule’s effect is unexpected, or the user is unsure why it hap-
pened, they can invoke the explanation inference. When a
profile is considered finished, model expansion can be per-
formed to identify the eligible assets, i.e., those that satisfy
the eligible definition. Moreover, using optimization, it is
possible to calculate minimal cost combinations of these el-
igible assets.
Besides these standard reasoning tasks, the collaborating
company requested a way to automatically convert the finan-
cial profile into a long and complex document with a specific
format. This document, called Appendix A, is used both as
an appendix to the contract with the client, and as the formal
input to one of the systems in place at the company. Previ-
ously, the company created such document manually, a pro-
cess which typically took a few months to complete. How-
ever, because the required knowledge of a financial profile
is already present in the KB, we were able to add a specific
method to automatically generate these documents in a few
seconds, as described by Deryck (2022).
As lessons learned, the authors outline two things. Firstly,
they mention that compared to standard applications in the
field of financial technology, their tool is low in maintenance
due to the separation between domain knowledge and rea-
soning tasks. Secondly, while the creation of a KB is typ-
ically a challenging task, the use of CNL is a good way of
lowering the effort.
5.4 Notary / Legislation
The fourth case study deals with registration duties on prop-
erty purchases in Belgium. It was originally presented by
Deryck et al. (2018) and later extended by Deryck et al.
(2019). In Belgium, registration duties depend on many pa-
rameters, such as the location, the type of property, the char-
acteristics of the buyer and the seller, and more. At the time
of the first publication, these duties were determined by 11
articles of law. For this case, a collaboration with a notary
was set up to ensure the correctness of the knowledge.
Initially, the knowledge engineer and domain expert
worked together to create a DMN model of the legislation.
Here, the user-friendliness of DMN meant that it could be
used as a “common language” between the two, leading to
less formalization errors. This is an important point, as the
law field contains a great deal of complex jargon. After
the DMN model was finished, the knowledge engineer con-
verted the tables into FO(·), ready to be used by the IDP sys-
tem. Together with the Interactive Consultant, this formed
an easy-to-use application. Note that standard DMN tools
would not have been sufficient, as the notary required a tool
that could reason with partial information and could opti-
mise the cost of the duties. In total, the formalization process
took 10 person-days.
Later in 2018, the relevant law was simplified by the Bel-
gian government. In (Deryck et al. 2019), the KB is up-
dated to reflect these changes, together with improvements
to the Interactive Consultant as requested by the notary of-
fice. While the change was the most significant change to
the real estate sales law to have ever happened, updating the
KB required only 0.5 person-days, due to the KB’s modular
This application has been ported to IDP-Z3, and is avail-
able online7. It takes advantage of the arithmetic capabilities
of IDP-Z3 to calculate the tax amount due.
6 Evaluation
We evaluate IDP-Z3 by comparing its functional capabilities
to those of other systems, and by comparing its performance
against user expectations.
6.1 Functional comparison to other systems
Table 1 compares FO(·) to two other model-based languages
on the basis of their documentation: SMT-LIB-2 (Barrett,
Stump, and Tinelli 2010) and ASP-Core-2 (Calimeri et al.
2012). Table 2 compares IDP-Z3 to reasoning engines for
SMT and ASP. The features in the comparison tables are
described in Sections 2.1 and 3.
None of the languages or systems are complete. Hence,
they are under further development to bring more expressiv-
ity to the languages, and more reasoning capability to the
reasoning engine.
Because they share many concepts, some researchers have
investigated the possibility to transform a KB in one lan-
guage into a KB in another, e.g., to improve performance:
• IDP-Z3 itself transforms FO(·) KBs into SMT-LIB-2
FOLASP transforms FO(·) KBs into ASP-Core-2, allow-
ing performance comparisons (Van Dessel, Devriendt,
and Vennekens 2021); the semantics correspondence be-
tween FO(ID) and ASP is explored in (Denecker et al.
and several ASP-Core-2 solvers are based on SMT solvers
(e.g., (Shen and Lierler 2018)).
We expect these investigations to continue.
6.2 Performance evaluation
Deryck et al. (2021) already reported response time below
3 seconds for the Intelli-Select application, for a typical in-
vestment profile.
We now discuss the performance of IDP-Z3 in the other
case studies. We believe that these results are representative
for other interactive applications based on IDP-Z3 and the
Interactive Consultant.
Table 3 shows various metrics and performance indicators
for each use case. The column headings are:
# symb: the number of symbols in the vocabulary;
Language FO(·) SMT ASP
Classical syntax X X
Types, quantification X X
Uninterpreted types X
(Inductive) definitions X X
Disjunction in head X
Integer arithmetic X X X
Real arithmetic X X -∗∗
Non-linear arithmetic X
Transcendental -
Aggregates X-X
Vector, Array X
Concept as a type X
Table 1: Comparison of model-based languages.
Not part of the standard, but provided by, e.g., Z3 or dReal.
∗∗Not part of the standard, but provided by Constraint-ASP solvers.
Reasoning IDP-Z3 SMT ASP
Model checking X X
Model expansion X X X
Propagation X-∗∗
Explanation (unsat) X X
Step-wise explanation -
Optimisation X-∗∗ X
Relevance X
Table 2: Comparison of model-based reasoning systems.
Provided by some solvers, e.g., IDP3.
∗∗Provided by some solvers, e.g., Z3.
Use case # symb model size # sentences load time (sec) response time (sec)
Component designer 92 227286 42 32.9 2.8
Adhesive selection 136 2061 154 8.3 2.5
Registration 31 31 15 0.3 0.1
Table 3: Response time is below 3 seconds, and load time acceptable.
model size: the size of a model, i.e., the sum of the cardi-
nality of the domain of each predicate and function sym-
bol (they all have a finite domain);
# sentences: the number of axioms and definitional rules
in the theory;
• load time: the number of seconds needed to load the
knowledge base in the Interactive Consultant;
resp. time: the number of seconds needed to process the
assertion or retraction of a fact (triggering a propagation).
The load and response times are measured on a Intel®
Core™ i7-8850H CPU @ 2.60GHz × 12 machine, with 16
GB of memory, using Ubuntu 20.04.03 and CPython 3.9.
The table shows that the load time can exceed 10 seconds
for KB with large models. This is not ideal, but still accept-
able in the use case presented. The delay is due to the trans-
formation of the FO(·) KB into the equivalent grounded FO
formula that is submitted to Z3: the transformation is per-
formed at every load, by code written in Python, a language
not known for its speed. Load time could be improved by
rewriting the transformation in a faster language, or by load-
ing the pre-computed result of the transformation directly
from storage.
The response time of the Interactive Consultant, on the
other hand, is below 3 seconds, an adequate delay for inter-
active applications. This is achieved by retaining the inter-
nal state of IDP-Z3 between interactions. Our experience
indicates that such retention is important in interactive ap-
plications based on IDP-Z3. Performance could be further
improved by parallelizing propagation, i.e., by running the
iterative satisfiability testing method over multiple instances
of Z3.
7 Conclusions
Thirty years ago, McCarthy introduced the concept of intel-
ligent machines of the fourth kind, capable of performing a
variety of computational tasks by applying task-independent
knowledge. Our work shows that such machines are now
feasible, and that interactive applications that deliver real
value to their users can be developed at low costs (typi-
cally 10 days of effort) and with acceptable performance
(response time typically below 3 seconds).
The following elements have contributed to this success:
Our use cases are knowledge-rich but data-poor, making
it possible to use computationally complex forms of rea-
soning. IDP-Z3 brings value by having knowledge that
the user may not have, and by reasoning faster and more
rigorously with it than an expert can.
IDP-Z3 goes beyond inference engines of the third kind
by allowing reasoning not only with deterministic rule-
based definitions, but also with non-deterministic axioms
describing possible worlds. Our result further justifies the
revival of interest in the seminal papers on the integra-
tion of rule-based languages and classical logic (Denecker
(2000), 20-year Test-of-Time award at ICLP 2020, and
Denecker, Pelov, and Bruynooghe (2001), 20-year Test-
of-Time award at ICLP 2021).
The use of generic reasoning methods (as recommended
in the Knowledge Base paradigm) and the automatic gen-
eration of the user interface of the Interactive Consultant
significantly reduce the development costs of intelligent
applications. User-friendly notations like DMN or Con-
trolled Natural Languages can further empower users to
encode their knowledge.
We believe that machines of the fourth kind merits further
research. The interaction between the user and the Interac-
tive Consultant has many similarities with the conversation
in a Turing test. Here, the interaction is not conducted in
a natural language, but the machine shows signs of intel-
ligence that would be tested in a Turing test, such as the
capability to ask relevant questions or provide explanations.
Additional research would expand the expressiveness of
the knowledge representation languages and/or improve the
performance of reasoning engine. The standardization of the
concrete syntax of FO(·) could facilitate such research.
This research received funding from the Flemish Govern-
ment under the “Onderzoeksprogramma Artifici¨
ele Intelli-
gentie (AI) Vlaanderen” programme.
The authors thank Ingmar Dasseville and Jo Devriendt for
their contributions to the development of IDP-Z3.
Aerts, B.; Deryck, M.; and Vennekens, J. 2022. Knowledge-
based decision support for machine component design: A
case study. Expert Systems with Applications 187:115869.
Barrett, C. W.; Sebastiani, R.; Seshia, S. A.; and Tinelli, C.
2009. Satisfiability modulo theories. In Biere, A.; Heule,
M.; van Maaren, H.; and Walsh, T., eds., Handbook of Sat-
isfiability, volume 185 of Frontiers in Artificial Intelligence
and Applications. IOS Press. 825–885.
Barrett, C.; Stump, A.; and Tinelli, C. 2010. The SMT-
LIB Standard: Version 2.0. In Gupta, A., and Kroening,
D., eds., Proceedings of the 8th International Workshop on
Satisfiability Modulo Theories (Edinburgh, UK).
Blackburn, P., and Bos, J. 2003. Computational semantics.
Theoria: An International Journal for Theory, History and
Foundations of Science 27–45.
Blackburn, P., and Bos, J. 2006. Working with discourse
representation theory. An Advanced Course in Computa-
tional Semantics.
Bogaerts, B.; Gamba, E.; Claes, J.; and Guns, T. 2020.
Step-wise explanations of constraint satisfaction problems.
In Giacomo, G. D.; Catal´
a, A.; Dilkina, B.; Milano, M.;
Barro, S.; Bugar´
ın, A.; and Lang, J., eds., ECAI 2020 - 24th
European Conference on Artificial Intelligence, 29 August-8
September 2020, Santiago de Compostela, Spain, August 29
- September 8, 2020 - Including 10th Conference on Pres-
tigious Applications of Artificial Intelligence (PAIS 2020),
volume 325 of Frontiers in Artificial Intelligence and Appli-
cations, 640–647. IOS Press.
Calimeri, F.; Faber, W.; Gebser, M.; Ianni, G.; Kaminski, R.;
Krennwallner, T.; Leone, N.; Ricca, F.; and Schaub, T. 2012.
Asp-core-2: Input language format. ASP Standardization
Working Group.
Carbonnelle, P.; Aerts, B.; Deryck, M.; Vennekens, J.; and
Denecker, M. 2019. An interactive consultant. In Pro-
ceedings of the 31st benelux conference on artificial intelli-
gence (BNAIC 2019) and the 28th belgian dutch conference
on machine learning (benelearn 2019), brussels, belgium,
november 6-8, 2019, volume 2491 of CEUR workshop pro-
Carbonnelle, P.; Bogaerts, B.; Vennekens, J.; and Denecker,
M. 2020. Interactive advisor for lax legislation and observ-
able situations. In Workshop on Models of Legal Reasoning,
Date: 2020/09/12-2020/09/14, Location: Rhodes, Greece.
Carbonnelle, P.; Van der Hallen, M.; Vennekens, J.; and De-
necker, M. 2022. Quantification and aggregation over con-
cepts of the ontology. In KR 2022 (submitted).
Claes, J.; Bogaerts, B.; Canoy, R.; and Guns, T. 2019. User-
oriented solving and explaining of natural language logic
grid puzzles. In The Third Workshop on Progress Towards
the Holy Grail.
Dasseville, I.; Janssens, L.; Janssens, G.; Vanthienen, J.; and
Denecker, M. 2016. Combining DMN and the knowledge
base paradigm for flexible decision enactment. In Athan,
T.; Giurca, A.; Gr¨
utter, R.; Proctor, M.; Teymourian, K.;
and Woensel, W. V., eds., Supplementary Proceedings of the
RuleML 2016 Challenge, Doctoral Consortium and Industry
Track hosted by the 10th International Web Rule Symposium,
RuleML 2016, New York, USA, July 6-9, 2016, volume 1620
of CEUR Workshop Proceedings.
De Cat, B.; Bogaerts, B.; and Denecker, M. 2014. Minisat
(id) for satisfiability checking and constraint solving. ALP
De Cat, B.; Jansen, J.; and Janssens, G. 2013. Idp3: Com-
bining symbolic and ground reasoning for model genera-
tion. In 2nd Workshop on Grounding and Transformations
for Theories With Variables, 17–24.
De Moura, L., and Bjørner, N. 2008. Z3: An efficient
smt solver. In International conference on Tools and Algo-
rithms for the Construction and Analysis of Systems, 337–
340. Springer.
Denecker, M., and Vennekens, J. 2008. Building a knowl-
edge base system for an integration of logic programming
and classical logic. In de la Banda, M. G., and Pontelli, E.,
eds., Logic Programming, 24th International Conference,
ICLP 2008, Udine, Italy, December 9-13 2008, Proceedings,
volume 5366 of Lecture Notes in Computer Science, 71–76.
Denecker, M.; Lierler, Y.; Truszczynski, M.; and Vennekens,
J. 2012. A tarskian informal semantics for answer set pro-
gramming. In Dovier, A., and Costa, V. S., eds., Techni-
cal Communications of the 28th International Conference
on Logic Programming, ICLP 2012, September 4-8, 2012,
Budapest, Hungary, volume 17 of LIPIcs, 277–289. Schloss
Dagstuhl - Leibniz-Zentrum f¨
ur Informatik.
Denecker, M.; Pelov, N.; and Bruynooghe, M. 2001. Ulti-
mate well-founded and stable semantics for logic programs
with aggregates. In Codognet, P., ed., Logic Program-
ming, 17th International Conference, ICLP 2001, Paphos,
Cyprus, November 26 - December 1, 2001, Proceedings,
volume 2237 of Lecture Notes in Computer Science, 212–
226. Springer.
Denecker, M. 2000. Extending classical logic with inductive
definitions. In Lloyd, J. W.; Dahl, V.; Furbach, U.; Kerber,
M.; Lau, K.; Palamidessi, C.; Pereira, L. M.; Sagiv, Y.; and
Stuckey, P. J., eds., Computational Logic - CL 2000, First
International Conference, London, UK, 24-28 July, 2000,
Proceedings, volume 1861 of Lecture Notes in Computer
Science, 703–717. Springer.
Deryck, M.; Hasi´
c, F.; Vanthienen, J.; and Vennekens, J.
2018. A case-based inquiry into the decision model and
notation (DMN) and the knowledge base (KB) paradigm.
In Rules and reasoning, volume 11092 of Lecture notes in
computer science, 248–263. Cham: Springer International
Deryck, M.; Devriendt, J.; Marynissen, S.; and Vennekens,
J. 2019. Legislation in the knowledge base paradigm: in-
teractive decision enactment for registration duties. In Pro-
ceedings of the 13th IEEE Conference on Semantic Comput-
ing, 174–177. IEEE. ISSN: 2325-6516.
Deryck, M.; Comenda, N.; Coppens, B.; and Vennekens,
J. 2021. Combining logic and natural language processing
to support investment management. In Proceedings of the
international conference on principles of knowledge repre-
sentation and reasoning, volume 18, 666–670. Number: 1.
Deryck, M. 2022. Knowledge Base Systems in practice:
Approaches, application areas and limitations. Ph.D. Dis-
sertation, KU Leuven.
Janota, M.; Lynce, I.; and Marques-Silva, J. 2015. Algo-
rithms for computing backbones of propositional formulae.
Ai Communications 28(2):161–177.
Jansen, J.; Bogaerts, B.; Devriendt, J.; Janssens, G.; and De-
necker, M. 2016. Relevance for SAT(ID). In Kambhampati,
S., ed., Proceedings of the Twenty-Fifth International Joint
Conference on Artificial Intelligence, IJCAI 2016, New York,
NY, USA, 9-15 July 2016, 596–602. IJCAI/AAAI Press.
Jordens, J.; Vandevelde, S.; Van Doninck, B.; Witters, M.;
and Vennekens, J. 2021. Adhesive selection via an interac-
tive, user-friendly system based on symbolic ai. In TODO.
Kowalski, R. 1979. Algorithm= logic+control. Communi-
cations of the ACM 22(7):424–436.
McCarthy, J. 1989. Artificial intelligence, logic and formal-
izing common sense. In Philosophical logic and artificial
intelligence. Springer. 161–190.
McCarthy, J. 1998. Elaboration tolerance. In Common
Sense, volume 98. Citeseer.
Nute, D. 2001. Defeasible logic. In Proceedings of the 14th
International Conference on Applications of Prolog, INAP
2001, University of Tokyo, Tokyo, Japan, October 20-22,
2001, 87–114. The Prolog Association of Japan.
Object Modelling Group. 2021. Decision model and nota-
tion v1.3.
Pelov, N., and Ternovska, E. 2005. Reducing inductive def-
initions to propositional satisfiability. In International Con-
ference on Logic Programming, 221–234. Springer.
Reiter, R. 1980. A logic for default reasoning. Artif. Intell.
Shen, D., and Lierler, Y. 2018. Smt-based answer set
solver CMODELS(DIFF) (system description). In Pal`
A. D.; Tarau, P.; Saeedloei, N.; and Fodor, P., eds., Tech-
nical Communications of the 34th International Conference
on Logic Programming, ICLP 2018, July 14-17, 2018, Ox-
ford, United Kingdom, volume 64 of OASICS, 11:1–11:15.
Schloss Dagstuhl - Leibniz-Zentrum f¨
ur Informatik.
Van Dessel, K.; Devriendt, J.; and Vennekens, J. 2021. FO-
LASP: FO(·) as Input Language for Answer Set Solvers.
Theory and practice of logic programming 21(6):785–801.
Vandevelde, S.; Aerts, B.; and Vennekens, J. 2021. Tack-
ling the DM challenges with cDMN: A tight integration of
DMN and constraint reasoning. Theory And Practice Of
Logic Programming. Publisher: Cambridge University Press
Vandevelde, S., and Vennekens, J. 2020. A multifunctional,
interactive DMN decision modelling tool. In Proceedings of
BNAIC/BeneLearn 2020, 399–400. Leiden University.
Von Wright, G. H. 1951. Deontic logic. Mind 60(237):1–15.
Wang, H. 1952. Logic of many-sorted theories. The Journal
of Symbolic Logic 17(2):105–116.
Zhang, Y.; Pu, G.; and Zhang, M. 2019. Smtbcf: Effi-
cient backbone computing for smt formulas. In Interna-
tional Conference on Formal Engineering Methods, 36–51.
ResearchGate has not been able to resolve any citations for this publication.
Conference Paper
Full-text available
In this demo we showcase DMN-IDP, a user-friendly tool which combines the readability of the Decision Model and Notation (DMN) standard with the power of the IDP system through an interactive interface. The Decision Model and Notation (DMN) standard is a table-based way of representing decision logic, with a focus on readability and user-friendliness. Designed by the Object Management Group, it was quickly adopted in various industries. In academia, interest in DMN to represent knowledge is also growing, because of its accessibility as a modelling language for domain experts [6]. To use DMN models, tools exist which can compute a suitable assignment of values to the decision variables, given the values of the environmental variables, by means of forward propagation. In [4], it was argued that the knowledge expressed in a DMN model can be used for much more. For instance, value propagation can also be done in other directions, such as from decision to environmental variables. Other examples are reasoning on incomplete data, and applying different inference tasks, such as optimization. To illustrate their approach, the authors made use of the IDP knowledge base system [5]. By manually translating DMN models into first-order logic knowledge bases (KBs), users could interact with the KB in a user-friendly way via a browser-based interface. While this results in a powerful and flexible way of working, there are two main downsides. Firstly, the DMN models need to be created in a separate tool. Secondly, the translation from DMN to IDP KB is done manually, for which knowledge of the representation language of the IDP system is required. In this demo, we present DMN-IDP, a full-fledged DMN tool which combines the dmn-js DMN editor [2] and the IDP-based Interactive Consultant interface [3]. Using this tool, a user can upload or create DMN models, which are then translated into IDP KBs. Users can interact with these models via the Interactive Consultant interface. The translation from DMN to IDP is done by the same transformation used in the cDMN framework [1]. The interface supports propagating values in any direction, reasoning on incomplete data, optimization of values and explanation of decisions. In this way, DMN models become useable in more situations, removing the need to build specific models for every target output in a use case.
Conference Paper
Full-text available
Inductive definitions and justifications are well-studied concepts. Solvers that support inductive definitions have been developed, but several of their computationally nice properties have never been exploited to improve these solvers. In this paper, we present a new notion called relevance. We determine a class of literals that are relevant for a given definition and partial interpretation, and show that choices on irrelevant atoms can never benefit the search for a model. We propose an early stopping criterion and a modification of existing heuris-tics that exploit relevance. We present a first implementation in MinisatID and experimentally evaluate our approach, and study how often existing solvers make choices on irrelevant atoms.
Full-text available
The problem of propositional satisfiability (SAT) has found a number of applications in both theoretical and practical computer science. In many applications, however, knowing a formula's satisfiability alone is insufficient. Often, some other properties of the formula need to be computed. This article focuses on one such property: the backbone of a formula, which is the set of literals that are true in all the formula's models. Backbones find theoretical applications in characterization of SAT problems and they also find practical applications in product configuration or fault localization. This article overviews existing algorithms for backbone computation and introduces two novel ones. Further, an extensive evaluation of the algorithms is presented. This evaluation demonstrates that one of the novel algorithms significantly outperforms the existing ones.
Conference Paper
Adhesive joints are increasingly used in industry for a wide variety of applications because of their favorable characteristics such as high strength-to-weight ratio, design flexibility, limited stress concentrations, planar force transfer, good damage tolerance and fatigue resistance. Selection of a proper adhesive for a particular application depends on many often conflicting product and manufacturing process requirements and is therefore a cumbersome task. Traditionally, adhesive selection is done by an adhesive expert based on experience, prior knowledge and trial and error. Adequate tooling to support adhesive bonding experts in the design processes is lacking, generally yielding suboptimal results. This research presents an interactive adhesive selector tool, aimed at supporting the design of adhesive joints. Knowledge on the gluing process and its associated constraints is captured from adhesive experts and represented formally in a Knowledge Base (KB). The knowledge inside the KB is then processed using the Imperative Declarative Programming (IDP) reasoning engine in order to support the adhesive selection. Through an intelligible, interactive, interface the application requirements (such as use conditions, materials, process requirements, etc.) are entered, based on which the IDP system reduces the search space of potential adhesives. The selector tool has been tested on an industrially relevant case in which an adhesive had to be selected for bonding a composite panel to a steel frame for an automotive application. Using the selector tool, an adhesive expert was able to select an appropriate adhesive 10 times faster than without.
Knowledge-based AI typically depends on a knowledge engineer to construct a formal model of domain knowledge – but what if domain experts could do this themselves? This paper describes an extension to the Decision Model and Notation (DMN) standard, called Constraint Decision Model and Notation (cDMN). DMN is a user-friendly, table-based notation for decision logic, which allows domain experts to model simple decision procedures without the help of IT staff. cDMN aims to enlarge the expressiveness of DMN in order to model more complex domain knowledge, while retaining DMNs goal of being understandable by domain experts. We test cDMN by solving the most complex challenges posted on the DM Community website. We compare our own cDMN solutions to the solutions that have been submitted to the website and find that our approach is competitive. Moreover, cDMN is able to solve more challenges than any other approach.
Conference Paper
This paper presents an application that we developed to assist users with the creation of an investment profile for the selection of financial assets. It consists of a natural language interface, an automatic translation to a declarative FO(.) knowledge base, and the IDP reasoning engine with multiple forms of logical inference. The application speeds up the investment profile creation process, and reduces the considerable inherent operational risk linked to the creation of investment profiles
This paper describes research conducted during a project with a multinational company that focuses on product design. The project tackles two different goals: providing sales staff with a tool that allows them to autonomously handle routine requests, and providing the company’s engineers with a decision support system to help them design products for more challenging application areas. For the first goal, we make use of a deterministic decision process, represented in the recent Decision Model and Notation (DMN) standard. For the second goal, we propose a constraint-based method. There, we use the IDP system to provide a number of interactive functionalities based on a logical representation of the relevant constraints. To ensure that the system is maintainable, we want the constraints to be updated by the engineers themselves. The IDP language is not ideal for this. Instead, we propose the cDMN notation, which extends the user-friendly DMN to constraints.
Standardization of solver input languages has been a main driver for the growth of several areas within knowledge representation and reasoning, fostering the exploitation in actual applications. In this document, we present the ASP-CORE-2 standard input language for Answer Set Programming, which has been adopted in ASP Competition events since 2013.