All right, good.
So thank you for joining me this afternoon for this presentation.
I'm a researcher at KU Leuven, and I'll be talking about our work on a reasoning engine
for FODOT.
So this morning, I connected to Chad GPT, and I asked him, or it, I don't know, what's
the, I'm twice the age of my son, who is 15 years younger than me, or old MI.
And it started pretty well by saying that let's give it, let's give a variable a name,
and then let's write the formula.
But then when it tried to solve the equation, somehow he got lost, and he was not able to
find the correct answer.
And that shows that Chad GPT is very capable at understanding English, but not so much
about reasoning, about, it does not have the cognitive skills to solve the equation.
And so if we ever will be able to create a machine that can pass the Turing test, of
course it needs to be able to handle natural language, but it also has to have the cognitive
skills that we human have, like those listed here, we should be able, it should be able
to learn from others through symbolic communication.
It should be able to apply knowledge in new ways to perform new tasks, like the capacity
to solve an equation, that's a knowledge that you can apply in many different settings.
And it should have other cognitive skills, like the capability to ask relevant questions,
and to explain its reasoning.
In all these types of skills, we try to implement them, and the field of study at the university
is called knowledge representation and reasoning, and that's what we are working on.
Now one way to have a computer solve a riddle, like on the edge that I gave earlier, is to
program the system, to program the computer.
But there's a big difference between a statement in a program and a statement of knowledge.
If, for example, I write in a program that F is equal to M multiplied by A, that's a
statement in a procedure, you can compute F if you know M and A. But that's quite different
from what you would see in a physics book, where the second law of motion would really
mean that given any two of those quantities, you can compute the third one.
And so you can really reason in multiple directions, unlike in a procedural statement.
So that's a big difference between a program and knowledge.
And you might think that a prologue, because it's a so-called declarative language, does
not have that problem, but in fact it does.
If you have a prologue program, like you can vote if you are more than 18, it can only
compute vote from the fact that you are more than 18 or not.
It cannot go the other way around.
And that's quite unlike what you would write in a logic statement, that you can vote if
and only if your age is larger than 18.
And with that kind of statement, you should be able to say, to infer your age or at least
a minimum value of your age from your right to vote.
So really, a prologue is a programming language.
It's not a knowledge representation language.
Now, what is programming?
It's actually the process of translating the knowledge that we have of a problem into a
program that can then give a problem, solve it.
And then if you have another problem, you have to apply that knowledge and convert it
into another program, possibly, to solve it.
And so depending on what kind of information you get as input and what kind of information
you want as output, you will have to write different programs.
And sometimes these programs will be quite different, which is a pity because the knowledge
that is implicit in the program is the same.
So why do we have to write so many different programs?
This process, the industry of converting knowledge into a program is, of course, a big industry.
It's the acting industry.
That's what makes us live.
But still, there's possibly a better way to do it, and that's what we are working on.
If we can represent the knowledge into a knowledge base and then develop some generic inferences
depending on the type of problem that you have, then you don't have to rewrite the program
every time.
You can use a generic inference, give it the knowledge base that you have, the input of
your problem, and it will give you the answer.
So for example, for the age riddle that I had in the beginning, the generic inference
is what we call model search.
So we search for a model of the equation, and that's a very generic skill that can be
implemented once and then applied in many different ways.
So what is knowledge then?
Knowledge is a statement of knowledge, it's a statement that is true in all possible worlds,
like for example, the second law of motion.
It's true in all possible worlds that you can imagine.
You can also say that a statement of knowledge is true in all acceptable worlds.
That's what the law says, like the regulations, what is acceptable as a behavior.
Sometimes a statement of knowledge can be about what you desire the world to be.
So it's an expectation, or it can be about a particular situation that you face, and
all these are different propositional attitudes.
If you are interested in philosophy, you can go and look at Wittgenstein and his book,
but that's the idea behind this.
And so we have been thinking about what would be a good knowledge representation language,
what could be its good attributes, and it should be, it should use symbols that have
very simple semantics, like the age of a person, like very simple predicates and functions.
It should have statements that are close to natural language, so it should be very easy
to express a statement in natural language into a statement in knowledge representation,
and vice versa, when you have a representation of knowledge, you should be able to read it
very easily into a natural language.
And it should be expressive.
It should be able to express complex forms of knowledge.
So first order logic is a nice candidate for expressing knowledge.
That's why it's one of the basic language to express scientific knowledge, for example.
We do use it in school for a good purpose.
It has indeed some symbols with simple semantics.
The statements are close to natural language, but still it is not as expressive as we would
like it to be.
So it has a construct like quantification.
You can say for every x something is true, or there is an x such that something is true,
but it doesn't have aggregates.
It doesn't have inductive definitions, which are complex ways of explaining how you would
compute the value of some elements.
And so we introduce a language called fo dot, the dot being representing a list of extensions.
And so it's first order logic extended with types, or so-called sorts in the literature,
with definitions or inductive definitions, with arithmetic so that you can do some computations.
It's still this point limited to linear arithmetic, so you cannot do transcendental functions
like sine and cosine.
It supports aggregates, like counting the cardinality of elements that satisfy some conditions,
as well as the minimal or maximum, et cetera, and it has some more advanced functions like
you're dealing with partial functions, functions that are undefined for some values of their
arguments and intentional objects.
You can look at the documentation if you want to have more details.
Maybe I can give you some examples of statements.
The first one would be for regulation about COVID, and you could read it like this.
So if you want to do an activity of outdoor sports, then you have to finish it before
8 p.m. in the evening, and then either you have a mask or you have a COVID-safe ticket.
So the hat is a symbol, is a logic symbol for and, and the V is a logic symbol for all.
The second statement would be like for an organization of an event like this one, or
for a course, planning of a course.
For every course provided by the university, the number of students that attend the course
should be less than the capacity of the room of the course.
That's really a very simple statement that can then be used into, for the search of a
correct planning.
The bottom example is an example of a definition where you have rules that can be applied.
And the first, so it looks a little bit like a prologue statement that can then be used
to define the tax rate of, for, for, for, for selling a house, for example.
And so at KU Leuven, we have developed, we are developing these technologies.
I mentioned FODOT, which is one of the two knowledge representation language.
This is the more powerful one.
CDMN is a table-like way to, to introduce decision tables.
And it can be used by business, by, by business analysts, I would say, in a, and it's a little
bit simpler than, than FODOT.
Then IDPZ3 is your reasoning engine that can use that knowledge base, as well as some
inputs to compute, to, to, to perform some reasoning tasks.
And on top of that, we have developed the IC, the Interactive Concertant, as we call
it.
So it's a little bit like a machine that can pass a Turing test, but we vote the knowledge,
the natural language capabilities, but it can reason like a Turing test machine would,
would need to do.
And these parts are really generic.
So once it is developed, then it can be reused very, very easily.
So the IDPZ3 is the reasoning engine that has these capabilities.
It can ask questions like, is it possible, according to the knowledge base of the possible
words that we give him.
That's called model checking.
It can ask, you can ask him what would be a possible word, again, according to the knowledge,
the knowledge base.
That's model generation or model search, model expansion.
What is relevant?
What would, what should I get for, as information to check, to, to be able to construct a model
of the, of the, of the, of the knowledge base?
What are the consequences of some partial information that I have about a situation?
I have some information about the situation that I face.
What are the consequences of that?
It can then give you some explanations about those consequences.
Why this is a consequence?
So it can explain its own reasoning.
And it can also do some kind of optimization.
Again, you can look at the website to have some more information there.
So the reasoning engine is hosted in a Python program.
So it's a Python program that will tell which inference to, to, to, to perform.
And so it's easily downloadable from the, the Python package index.
And so let me talk about the interactive consultants.
Let's say that you have some challenge to engineer a design that meets some customer requirements.
Well, to address that challenge, we develop a novel class of applets that can perform
various forms of reasoning in, in the domain of expertise.
And that will help the engineer finds proper design.
So how does that work?
So you have the requirements that come from, from the outside, from the environment, from,
from, from the customer.
So you have a set of requirements.
The engineer will then interact with the application to enter the requirements that he knows.
As well as some tentative decisions that he thinks would be proper design.
And then in return, the system will ask him some additional question.
And really, you, you, you should know exactly what is the property of this material or what
is the expected operating temperature of the, of the system.
So it's, it's starting to have a conversation with the engineer.
It will tell him what are the prerequisites of his tentative decisions.
So if he says, oh, I'd like to use steel, well, the system says, okay, but then you
need to have, I don't know, some kind of pressure that is not higher than, than something
else, whatever.
It will tell him the consequences of his, of his decisions.
It will be able to give some explanations and then some do some optimization of the design.
So it's really a consultant that will help the engineer come to a solution.
And all that with some proprietary expertise of the domain of, of, of interest that will
be used to do the, the reasoning.
If I have time, I'll give you a quick demo, maybe I'll go through the slides first.
So we are developing that in partnership with some industrial partners.
It is a big multinational that prefers to keep privates.
I have five minutes left.
Thank you.
But we are also working with Siemens with Flandersmake, which is a research lab for
the industry in, in, in, in Flanders.
We entirely select in the, the banking sector, heads up with notaries.
And the idea is to reduce the decision time of, of some experts.
For example, in the Flandersmake, it was to reduce the time to select a glue, to glue
two materials together.
And typically they had to go through data sheets and to find the proper glue.
And with the tool, they cannot do it in less than five minutes.
And with the development cause, that was quite, quite low.
This is an example with the big multinational company.
They had to design custom industrial components.
The expertise of doing that was in the head of the experienced engineers.
But they wanted to empower the younger engineers.
And so we formalized the knowledge of the experts into the system.
And then with the interactive consultant, the younger engineers can play around with
the different options and find a proper design that is right the first time.
And the fact of formalizing the knowledge in, in the system really makes that knowledge
an asset of the company that can then be managed as an over asset.
And the organization becomes a learning organization.
So why do we do this now?
Why, why is it possible now and not before?
That's because there are new solvers that are capable of making those types of reasoning.
It's a big progress in the artificial intelligence world, but it's a little bit less well known
than neural networks and so on.
But it is quite, quite a nice progress.
And we try to put that into, into practice.
And also, we are getting a new understanding of what is knowledge and how to use it.
And that's why this is, this is an interesting area.
Let me go back to, to the demo.
So you can go to the IDPZ3, ooh, I don't have internet.
I did have it before.
Yeah, sorry about that.
So I won't be able to show it, but that's, that's the end of my presentation.
If there are any questions, I'll be happy to answer.
Thank you.
Yes.
Can you explain how this, how you approach differences from the classical expert systems?
What's the next step?
So, so yeah, the, the question is how is this, if I understand well, how is this different
from expert systems, right?
Because expert systems were quite popular back in the 80s and 90s.
And this looks very much the same.
But the thing is that expert systems were very much like prologue.
And so they could make inferences in one direction, but, but they could not reason with, with,
in, in any other direction.
So it could not reason with partial information, for example.
Well, here, even with partial information, it's capable of doing some, some, some, to,
to come up with, with some conclusions.
So it's very different from, from programming from, from knowledge.
Yeah.
So in the use case you presented, you said that you took the expert note.
How can you formalize it in order to be used by the original engine?
Yeah.
So the representation of the data is on FODAR.
Yes.
The representation of the knowledge is in FODAR.
Yes.
Okay.
How, what's the process of transferring the data?
We're just discussing with experts.
Right.
Yeah.
So for the moment it's done by a knowledge engineer, as we call it, who talks with the
experts and who looks in the data sheets and then that formalize it.
It's like a programmer if you want, but for knowledge.
So he has to, to, to formalize the knowledge into the, the, the formal language.
Okay.
And one more follow-up.
So data representation is something like a decision tree or something?
The, the representation is what I showed earlier.
These are statements in logic, like the one I showed.
Like this, this one's here.
Let's, let's go ahead and show.
So it would be statements like these that look very much like statement in English, but
they would use some kind of formal.
So the knowledge base is really just a text file.
Okay.
Steven?
Yeah.
Maybe one more.
You mentioned humor.
Yes.
It's not capable of that yet, but we are working on it.
All right.
Yeah.
One more.
Yeah.
Was it a lot of work to customize Z3 to work with this?
To work with this?
Yeah.
It was some, some work.
Yes.
So the question is, we use Z3 as a back end for the reasoning engine.
How much work did it require to build to the reasoning engine, engine that we, we have?
Of course, Z3 is already quite capable.
So it's very, very useful.
On top of that, we have new language constructs like aggregates that Z3 does not have.
Natively.
And we have also some additional inference or reasoning capabilities on top of it.
Like the term, determination of what is the relevant question in the particular case.
So, yeah.
The system capable of recognizing or even pointing out some coherent specifications in the knowledge
base.
Could you speak a bit louder?
I don't hear you.
Yes, indeed.
Right.
Yeah.
So the question is, what happens is the knowledge base have conflicting statements in it, because
then it cannot reason correctly.
And actually, we have an inference that will try to extract the minimum set of instances
of statements in it.
That will make the, that makes the knowledge base inconsistent.
And then from that inconsistent set of statements, we can try, the knowledge engineer can try
to resolve it.
Has that been used in practice?
It is used, yes, indeed.
Has that helped the specific case?
In that specific case, I don't remember exactly.
I couldn't say, but it could be.
I don't know if.
Yeah, this should come in.
No, no, come on.
And your picture is a big form.
I thought you were expecting the general picture.
There's still one question.
If you could stay quiet, please.
So the question is whether this could have applications in the medical field, where you
have some, I need to reason with some probabilities.
If there is this set of symptoms, there's a probability of such that this could happen.
At this point, we are not focusing on this type of reasoning with probabilities.
There's another group at KU11 that has developed the logic called probabilistic logic, which
is an evolution of prologue, which goes in that direction.
But this one does not do it.
All right, thank you very much.