Introduction
Everything in nature is bound by natural laws, and proceeds according to natural laws. However, scientists are unable, unwilling or forbidden to define intelligence as a set of natural laws. Not being based on laws of nature, Artificial Intelligence (AI) is not an artificial implementation of natural intelligence. Therefore, AI is not a fundamental science, but a field of engineering.
​
A fundamental science delivers generic solutions, while a field of engineering is limited to specific solutions to specific problems. And engineered solutions are limited to perform routine tasks. So, being a field of engineering, AI is limited to perform routine tasks.
​
However, it is possible to uplift this field of engineering towards a fundamental science, similar to the field of electromagnetism, which is based on laws of nature. Thanks to research on the natural laws of electromagnetism, we are able to close the loop for electricity, magnetism, light and movement. As a result, we are able to apply these conversions to daily life. We are able:
-
to convert electricity to magnetism, and to convert magnetism back to electricity;
-
to convert electricity to light, and to convert light back to electricity;
-
to convert electromagnetism to movement, and movement back to electromagnetism.
​
I am using fundamental science / basic research (logic and laws of nature) instead of cognitive science (simulation of behavior), in order to replicate natural intelligence in an artificial environment (software), because:
-
Autonomous reasoning requires both natural intelligence and natural language;
-
Intelligence and language are natural phenomena;
-
Natural phenomena obey laws of nature;
-
Laws of nature and logic are investigated using fundamental science.
​
By defining intelligence as a set of natural laws – and researching Laws of Intelligence that are naturally found in the Human Language – I am able to close the loop for natural intelligence and natural language. As a result, my system is able:
-
to convert readable sentences – with a limited grammar – to a logic that isn't described by scientists yet;
-
to autonomously derive new knowledge from previously unknown knowledge, using my extended logic;
-
and to express the derived knowledge in readable and autonomously – word by word – constructed sentences, with a limited grammar.
The logical rules of my autonomous reasoner are (almost) language-independent. So, I can add any language I like, just by configuring my reasoner for this new language, and a little bit of programming. My reasoner is already able to read, to autonomously reason and to autonomously write the derived knowledge in readable English, Spanish, French, Dutch and Chinese, while scientists are unable to develop a proper multilingual reasoner.
​
Therefore, I defy anyone to beat the simplest results of my Controlled Natural Language (CNL) reasoner in a generic way: from Controlled Natural Language, through algorithms, back to Controlled Natural Language, in multiple languages, without programmed or trained knowledge, without human-written output sentences, and without the use of extensive words lists.
Of course, this reasoner is available free of charge, and published as open source software.
Problem description 1: Reasoning in the past tense
Autonomous reasoning requires both natural intelligence and natural language. Aristotle already applied natural intelligence to natural language roughly 2,400 years ago:
​
Given:
-
“All philosophers are mortal.”
-
“Socrates is a philosopher.”
Logical conclusion:
-
“Socrates is mortal.”
​
However, at the time Aristotle described the natural reasoning example mentioned above, Socrates was already dead – the ultimate proof of his morality. So, actually, Aristotle should have used the past tense form in his example, regarding to Socrates:
​
Given:
-
“All philosophers are mortal.”
-
“Socrates was a philosopher.”
Logical conclusion:
-
“Socrates was mortal.”
​
The tense of a verb tells us about the state of the involved statement:
-
“Socrates is a philosopher” tells us that Socrates is still alive;
-
“Socrates was a philosopher” tells us that Socrates is no longer among the living.
​
In regard to the conclusion:
-
“Socrates is mortal” tells us that the death of Socrates is inevitable, but that his mortality isn't proven yet by hard evidence;
-
“Socrates was mortal” tells us that his mortality is proven by hard evidence.
So, why isn’t past tense reasoning naturally supported by predicate logic (algebra)? Why should any past tense predicate be engineered – and described in an artificial way – like was_philosopher(socrates) and was_mortal(socrates)? Why is predicate logic (algebra) still not fully equipped for natural language, after those centuries of scientific research?
Problem description 2: Possessive reasoning
Also possessive reasoning – reasoning using possessive imperative “have” – isn’t naturally supported by predicate logic (algebra):
​
Given:
-
“Paul is a son of John.”
Logical conclusion:
-
“John has a son, called Paul.”
​
Or the other way around:
​
Given:
-
“John has a son, called Paul.”
Logical conclusion:
-
“Paul is a son of John.”
​
So, why doesn't predicate logic (algebra) support possessive reasoning in a natural way? Why should any predicate that can’t be expressed using imperative “are” in the present tense be engineered – and described in an artificial way – like has_son(john,paul)? Why is predicate logic (algebra) still not equipped for automating natural language, in this computer era?
Problem description 3: Generation of questions
Algebra describes the Exclusive OR (XOR) function, while CNL reasoners don't implement its linguistic equivalent: conjunction “or”. CNL reasoners are therefore unable to generate the following question:
Given:
-
“Every person is a man or a woman.”
-
“Addison is a person.”
Logical question:
-
“Is Addison a man or a woman?”
​
Everything in nature is connected. However, scientists have artificially separated logic (Exact sciences) from language (Humanities), by which the Logic of Language isn’t fully described yet. In my experience, linguists, philosophers and mathematicians all point to each other when it comes to describing the Logic of Language in a fundamental way. Let alone, defining natural intelligence as a set of Natural Laws, for example found in natural language.
Like a programming language, also natural language has structure words and variables. The structure words of language – which in this document are printed in blue – have a naturally intelligent, logical, structure-providing function in language. The following structure words of language will be illustrated in this challenge document:
Possessive verb “has/have” (Block 1, Block 2 and Block 3), past tense verbs “was/were” and “had” (Block 4), conjunction “or” (Block 5) and definite article “the” (Block 6).
Generally accepted workaround
The generally accepted workaround in the field of Artificial Intelligence (AI) and knowledge technology (NLP), to enter knowledge containing imperative “have”, is to program it directly into a reasoner, like: has_son(john,paul). However, this is not a generic solution (=science), but a specific solution to a specific problem (=engineering). Because it requires to program each and every noun directly into the reasoner (has_daughter, has_father, has_mother, and so on), and for each and every new language. As a consequence, there is no technique available to convert a sentence like “Paul is a son of John” to “John has a son, called Paul” in a generic way – from natural language, through an algorithm, to natural language – by which noun “son” and proper nouns “Paul” and “John” don't have to be programmed into the reasoner. It is just the first example of this challenge (see Block 1).
Below, a contribution I received from a student, in an attempt to solve this problem. With his permission, his Excel implementation for the English language:
​
= IF(ISERROR(SEARCH("has a";A1));MID(A1;SEARCH("of";A1)+3;999) & " has a" & IF(ISERROR(SEARCH("is an";A1));" ";"n ") & MID(SUBSTITUTE(A1;"is an";"is a");SEARCH("is a"; SUBSTITUTE(A1;"is an";"is a"))+5;SEARCH("of"; SUBSTITUTE(A1;"is an";"is a"))-SEARCH("is";SUBSTITUTE(A1;"is an";"is a"))-6) & " called " & LEFT(A1;SEARCH("is";SUBSTITUTE(A1;"is an";"is a"))-1);MID(SUBSTITUTE(A1;"has an";"has a");SEARCH("called";SUBSTITUTE(A1;"has an";"has a"))+7;999) & " is a" & IF(ISERROR(SEARCH("has an";A1));" ";"n ") & MID(SUBSTITUTE(A1;"has an";"has a");SEARCH("has a"; SUBSTITUTE(A1;"has an";"has a"))+6;SEARCH("called"; SUBSTITUTE(A1;"has an";"has a"))-SEARCH("has";SUBSTITUTE(A1;"has an";"has a"))-7) & " of " & LEFT(A1;SEARCH("has";SUBSTITUTE(A1;"has an";"has a"))-1))
This solution doesn't check for word types, as explained in paragraph 1.6.2. The function of word types in reasoning of my fundamental document. Besides that, this logic needs to be copied for each language, while a generic solution has only one logical implementation. Moreover, this implementation can't be expanded to process for example multiple specifications words, like in: “Paul is a son of John and Anna” or “John has two sons, called Paul and Joe”. So, this implementation is not flexible. Therefore, it is not generic, and thus not scientific.
The field of AI and NLP is “inspired by nature”. But it has no foundation in nature. Therefore, this field is limited to deliver specific solutions to specific problems (=engineering), like the Excel implementation mentioned above. However, this challenge is about uplifting this field of engineering towards a fundamental science, by developing generic solutions, based on a foundation in nature, like I am developing.
My fundamental approach shows that imperative “have” is complementary to imperative “are”, by which also imperative “have” can be used in predicate logic, in a natural way. In order to utilize the naturally intelligent function of non-keywords (structure words), I have defined natural intelligence first. Then I have identified a few Laws of Intelligence that are naturally present in Language. And by implementing these laws of nature as a set of structuring algorithms is my system able to structure the knowledge of the system autonomously.
The rules of this challenge
-
There are 8 blocks to beat the most basic techniques of my system. Your implementation should deliver the results of at least one block listed below;
-
Your implementation should not have any prior knowledge. Instead, it should derive its knowledge from the input sentences of the examples listed below, from readable language, through an algorithm, back to readable language;
-
Preferable: The nouns and proper nouns of the listed examples are unknown upfront. (I use grammar definitions and an algorithm instead of a words list);
-
Your implementation should be implemented as generic as can be, in such a way that all examples of this challenge can be integrated into one single system. The screenshots of my CNL reasoner illustrate how multiple reasoning constructions reinforce each other. At the end of each block, a screenshot is added to illustrate how my software handles the examples of this challenge;
-
Your implementation should be published as open source software, so that its functionality is transparent. My software is published as open source software too;
-
Your implementation should be accepted by a scientific committee (conference or journal);
-
In case your results are slightly different, you need to explain why you have chosen differently;
-
It is an on-going challenge, until all blocks have been scientifically accepted;
-
I am the jury.
​
Your rewards:
-
A small gesture from me: €1,000 for each of the blocks 1 to 6 to be scientifically accepted, and €2,000 for each of the blocks 7 and 8 to be scientifically accepted. So, €10,000 in total, for all 8 blocks;
-
You will be the first one to have described in a scientifically accepted way, the logic of language that I have discovered.
​
You can contact me via LinkedIn.
Menu
Scientific challenge (Introduction)